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)
1202                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1203                 data_size= samples_size;
1204                     /* XXX: could avoid copy if PCM 16 bits with same
1205                        endianness as CPU */
1206                 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1207                                            ptr, len);
1208                 if (ret < 0)
1209                     goto fail_decode;
1210                 ptr += ret;
1211                 len -= ret;
1212                 /* Some bug in mpeg audio decoder gives */
1213                 /* data_size < 0, it seems they are overflows */
1214                 if (data_size <= 0) {
1215                     /* no audio frame */
1216                     continue;
1217                 }
1218                 data_buf = (uint8_t *)samples;
1219                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1220                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1221                 break;}
1222             case CODEC_TYPE_VIDEO:
1223                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1224                     /* XXX: allocate picture correctly */
1225                     avcodec_get_frame_defaults(&picture);
1226
1227                     ret = avcodec_decode_video(ist->st->codec,
1228                                                &picture, &got_picture, ptr, len);
1229                     ist->st->quality= picture.quality;
1230                     if (ret < 0)
1231                         goto fail_decode;
1232                     if (!got_picture) {
1233                         /* no picture yet */
1234                         goto discard_packet;
1235                     }
1236                     if (ist->st->codec->time_base.num != 0) {
1237                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1238                                           ist->st->codec->time_base.num) /
1239                             ist->st->codec->time_base.den;
1240                     }
1241                     len = 0;
1242                     break;
1243             case CODEC_TYPE_SUBTITLE:
1244                 ret = avcodec_decode_subtitle(ist->st->codec,
1245                                               &subtitle, &got_subtitle, ptr, len);
1246                 if (ret < 0)
1247                     goto fail_decode;
1248                 if (!got_subtitle) {
1249                     goto discard_packet;
1250                 }
1251                 subtitle_to_free = &subtitle;
1252                 len = 0;
1253                 break;
1254             default:
1255                 goto fail_decode;
1256             }
1257         } else {
1258             switch(ist->st->codec->codec_type) {
1259             case CODEC_TYPE_AUDIO:
1260                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1261                     ist->st->codec->sample_rate;
1262                 break;
1263             case CODEC_TYPE_VIDEO:
1264                 if (ist->st->codec->time_base.num != 0) {
1265                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1266                                       ist->st->codec->time_base.num) /
1267                         ist->st->codec->time_base.den;
1268                 }
1269                 break;
1270             }
1271             data_buf = ptr;
1272             data_size = len;
1273             ret = len;
1274             len = 0;
1275         }
1276
1277         buffer_to_free = NULL;
1278         if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1279             pre_process_video_frame(ist, (AVPicture *)&picture,
1280                                     &buffer_to_free);
1281         }
1282
1283         // preprocess audio (volume)
1284         if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1285             if (audio_volume != 256) {
1286                 short *volp;
1287                 volp = samples;
1288                 for(i=0;i<(data_size / sizeof(short));i++) {
1289                     int v = ((*volp) * audio_volume + 128) >> 8;
1290                     if (v < -32768) v = -32768;
1291                     if (v >  32767) v = 32767;
1292                     *volp++ = v;
1293                 }
1294             }
1295         }
1296
1297         /* frame rate emulation */
1298         if (ist->st->codec->rate_emu) {
1299             int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1300             int64_t now = av_gettime() - ist->start;
1301             if (pts > now)
1302                 usleep(pts - now);
1303
1304             ist->frame++;
1305         }
1306
1307 #if 0
1308         /* mpeg PTS deordering : if it is a P or I frame, the PTS
1309            is the one of the next displayed one */
1310         /* XXX: add mpeg4 too ? */
1311         if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1312             if (ist->st->codec->pict_type != B_TYPE) {
1313                 int64_t tmp;
1314                 tmp = ist->last_ip_pts;
1315                 ist->last_ip_pts  = ist->frac_pts.val;
1316                 ist->frac_pts.val = tmp;
1317             }
1318         }
1319 #endif
1320         /* if output time reached then transcode raw format,
1321            encode packets and output them */
1322         if (start_time == 0 || ist->pts >= start_time)
1323             for(i=0;i<nb_ostreams;i++) {
1324                 int frame_size;
1325
1326                 ost = ost_table[i];
1327                 if (ost->source_index == ist_index) {
1328                     os = output_files[ost->file_index];
1329
1330 #if 0
1331                     printf("%d: got pts=%0.3f %0.3f\n", i,
1332                            (double)pkt->pts / AV_TIME_BASE,
1333                            ((double)ist->pts / AV_TIME_BASE) -
1334                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1335 #endif
1336                     /* set the input output pts pairs */
1337                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1338
1339                     if (ost->encoding_needed) {
1340                         switch(ost->st->codec->codec_type) {
1341                         case CODEC_TYPE_AUDIO:
1342                             do_audio_out(os, ost, ist, data_buf, data_size);
1343                             break;
1344                         case CODEC_TYPE_VIDEO:
1345                             do_video_out(os, ost, ist, &picture, &frame_size);
1346                             if (vstats_filename && frame_size)
1347                                 do_video_stats(os, ost, frame_size);
1348                             break;
1349                         case CODEC_TYPE_SUBTITLE:
1350                             do_subtitle_out(os, ost, ist, &subtitle,
1351                                             pkt->pts);
1352                             break;
1353                         default:
1354                             abort();
1355                         }
1356                     } else {
1357                         AVFrame avframe; //FIXME/XXX remove this
1358                         AVPacket opkt;
1359                         av_init_packet(&opkt);
1360
1361                         if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1362                             continue;
1363
1364                         /* no reencoding needed : output the packet directly */
1365                         /* force the input stream PTS */
1366
1367                         avcodec_get_frame_defaults(&avframe);
1368                         ost->st->codec->coded_frame= &avframe;
1369                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1370
1371                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1372                             audio_size += data_size;
1373                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1374                             video_size += data_size;
1375                             ost->sync_opts++;
1376                         }
1377
1378                         opkt.stream_index= ost->index;
1379                         if(pkt->pts != AV_NOPTS_VALUE)
1380                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1381                         else
1382                             opkt.pts= AV_NOPTS_VALUE;
1383
1384                         if (pkt->dts == AV_NOPTS_VALUE)
1385                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1386                         else
1387                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1388
1389                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1390                         opkt.flags= pkt->flags;
1391
1392                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1393                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1394                             opkt.destruct= av_destruct_packet;
1395
1396                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1397                         ost->st->codec->frame_number++;
1398                         ost->frame_number++;
1399                         av_free_packet(&opkt);
1400                     }
1401                 }
1402             }
1403         av_free(buffer_to_free);
1404         /* XXX: allocate the subtitles in the codec ? */
1405         if (subtitle_to_free) {
1406             if (subtitle_to_free->rects != NULL) {
1407                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1408                     av_free(subtitle_to_free->rects[i].bitmap);
1409                     av_free(subtitle_to_free->rects[i].rgba_palette);
1410                 }
1411                 av_freep(&subtitle_to_free->rects);
1412             }
1413             subtitle_to_free->num_rects = 0;
1414             subtitle_to_free = NULL;
1415         }
1416     }
1417  discard_packet:
1418     if (pkt == NULL) {
1419         /* EOF handling */
1420
1421         for(i=0;i<nb_ostreams;i++) {
1422             ost = ost_table[i];
1423             if (ost->source_index == ist_index) {
1424                 AVCodecContext *enc= ost->st->codec;
1425                 os = output_files[ost->file_index];
1426
1427                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1428                     continue;
1429                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1430                     continue;
1431
1432                 if (ost->encoding_needed) {
1433                     for(;;) {
1434                         AVPacket pkt;
1435                         int fifo_bytes;
1436                         av_init_packet(&pkt);
1437                         pkt.stream_index= ost->index;
1438
1439                         switch(ost->st->codec->codec_type) {
1440                         case CODEC_TYPE_AUDIO:
1441                             fifo_bytes = av_fifo_size(&ost->fifo);
1442                             ret = 0;
1443                             /* encode any samples remaining in fifo */
1444                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1445                                 int fs_tmp = enc->frame_size;
1446                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1447                                 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1448                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1449                                 enc->frame_size = fs_tmp;
1450                             }
1451                             if(ret <= 0) {
1452                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1453                             }
1454                             audio_size += ret;
1455                             pkt.flags |= PKT_FLAG_KEY;
1456                             break;
1457                         case CODEC_TYPE_VIDEO:
1458                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1459                             video_size += ret;
1460                             if(enc->coded_frame && enc->coded_frame->key_frame)
1461                                 pkt.flags |= PKT_FLAG_KEY;
1462                             if (ost->logfile && enc->stats_out) {
1463                                 fprintf(ost->logfile, "%s", enc->stats_out);
1464                             }
1465                             break;
1466                         default:
1467                             ret=-1;
1468                         }
1469
1470                         if(ret<=0)
1471                             break;
1472                         pkt.data= bit_buffer;
1473                         pkt.size= ret;
1474                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1475                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1476                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1477                     }
1478                 }
1479             }
1480         }
1481     }
1482
1483     return 0;
1484  fail_decode:
1485     return -1;
1486 }
1487
1488 static void print_sdp(AVFormatContext **avc, int n)
1489 {
1490     char sdp[2048];
1491
1492     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1493     printf("SDP:\n%s\n", sdp);
1494 }
1495
1496 static int stream_index_from_inputs(AVFormatContext **input_files,
1497                                     int nb_input_files,
1498                                     AVInputFile *file_table,
1499                                     AVInputStream **ist_table,
1500                                     enum CodecType type,
1501                                     int programid)
1502 {
1503     int p, q, z;
1504     for(z=0; z<nb_input_files; z++) {
1505         AVFormatContext *ic = input_files[z];
1506         for(p=0; p<ic->nb_programs; p++) {
1507             AVProgram *program = ic->programs[p];
1508             if(program->id != programid)
1509                 continue;
1510             for(q=0; q<program->nb_stream_indexes; q++) {
1511                 int sidx = program->stream_index[q];
1512                 int ris = file_table[z].ist_index + sidx;
1513                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1514                     return ris;
1515             }
1516         }
1517     }
1518
1519     return -1;
1520 }
1521
1522 /*
1523  * The following code is the main loop of the file converter
1524  */
1525 static int av_encode(AVFormatContext **output_files,
1526                      int nb_output_files,
1527                      AVFormatContext **input_files,
1528                      int nb_input_files,
1529                      AVStreamMap *stream_maps, int nb_stream_maps)
1530 {
1531     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1532     AVFormatContext *is, *os;
1533     AVCodecContext *codec, *icodec;
1534     AVOutputStream *ost, **ost_table = NULL;
1535     AVInputStream *ist, **ist_table = NULL;
1536     AVInputFile *file_table;
1537     int key;
1538     int want_sdp = 1;
1539
1540     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1541     if (!file_table)
1542         goto fail;
1543
1544     /* input stream init */
1545     j = 0;
1546     for(i=0;i<nb_input_files;i++) {
1547         is = input_files[i];
1548         file_table[i].ist_index = j;
1549         file_table[i].nb_streams = is->nb_streams;
1550         j += is->nb_streams;
1551     }
1552     nb_istreams = j;
1553
1554     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1555     if (!ist_table)
1556         goto fail;
1557
1558     for(i=0;i<nb_istreams;i++) {
1559         ist = av_mallocz(sizeof(AVInputStream));
1560         if (!ist)
1561             goto fail;
1562         ist_table[i] = ist;
1563     }
1564     j = 0;
1565     for(i=0;i<nb_input_files;i++) {
1566         is = input_files[i];
1567         for(k=0;k<is->nb_streams;k++) {
1568             ist = ist_table[j++];
1569             ist->st = is->streams[k];
1570             ist->file_index = i;
1571             ist->index = k;
1572             ist->discard = 1; /* the stream is discarded by default
1573                                  (changed later) */
1574
1575             if (ist->st->codec->rate_emu) {
1576                 ist->start = av_gettime();
1577                 ist->frame = 0;
1578             }
1579         }
1580     }
1581
1582     /* output stream init */
1583     nb_ostreams = 0;
1584     for(i=0;i<nb_output_files;i++) {
1585         os = output_files[i];
1586         if (!os->nb_streams) {
1587             fprintf(stderr, "Output file does not contain any stream\n");
1588             av_exit(1);
1589         }
1590         nb_ostreams += os->nb_streams;
1591     }
1592     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1593         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1594         av_exit(1);
1595     }
1596
1597     /* Sanity check the mapping args -- do the input files & streams exist? */
1598     for(i=0;i<nb_stream_maps;i++) {
1599         int fi = stream_maps[i].file_index;
1600         int si = stream_maps[i].stream_index;
1601
1602         if (fi < 0 || fi > nb_input_files - 1 ||
1603             si < 0 || si > file_table[fi].nb_streams - 1) {
1604             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1605             av_exit(1);
1606         }
1607         fi = stream_maps[i].sync_file_index;
1608         si = stream_maps[i].sync_stream_index;
1609         if (fi < 0 || fi > nb_input_files - 1 ||
1610             si < 0 || si > file_table[fi].nb_streams - 1) {
1611             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1612             av_exit(1);
1613         }
1614     }
1615
1616     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1617     if (!ost_table)
1618         goto fail;
1619     for(i=0;i<nb_ostreams;i++) {
1620         ost = av_mallocz(sizeof(AVOutputStream));
1621         if (!ost)
1622             goto fail;
1623         ost_table[i] = ost;
1624     }
1625
1626     n = 0;
1627     for(k=0;k<nb_output_files;k++) {
1628         os = output_files[k];
1629         for(i=0;i<os->nb_streams;i++) {
1630             int found;
1631             ost = ost_table[n++];
1632             ost->file_index = k;
1633             ost->index = i;
1634             ost->st = os->streams[i];
1635             if (nb_stream_maps > 0) {
1636                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1637                     stream_maps[n-1].stream_index;
1638
1639                 /* Sanity check that the stream types match */
1640                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1641                     int i= ost->file_index;
1642                     dump_format(output_files[i], i, output_files[i]->filename, 1);
1643                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1644                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1645                         ost->file_index, ost->index);
1646                     av_exit(1);
1647                 }
1648
1649             } else {
1650                 if(opt_programid) {
1651                     found = 0;
1652                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1653                     if(j != -1) {
1654                         ost->source_index = j;
1655                         found = 1;
1656                     }
1657                 } else {
1658                     /* get corresponding input stream index : we select the first one with the right type */
1659                     found = 0;
1660                     for(j=0;j<nb_istreams;j++) {
1661                         ist = ist_table[j];
1662                         if (ist->discard &&
1663                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1664                             ost->source_index = j;
1665                             found = 1;
1666                             break;
1667                         }
1668                     }
1669                 }
1670
1671                 if (!found) {
1672                     if(! opt_programid) {
1673                         /* try again and reuse existing stream */
1674                         for(j=0;j<nb_istreams;j++) {
1675                             ist = ist_table[j];
1676                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1677                                 ost->source_index = j;
1678                                 found = 1;
1679                             }
1680                         }
1681                     }
1682                     if (!found) {
1683                         int i= ost->file_index;
1684                         dump_format(output_files[i], i, output_files[i]->filename, 1);
1685                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1686                                 ost->file_index, ost->index);
1687                         av_exit(1);
1688                     }
1689                 }
1690             }
1691             ist = ist_table[ost->source_index];
1692             ist->discard = 0;
1693             ost->sync_ist = (nb_stream_maps > 0) ?
1694                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1695                          stream_maps[n-1].sync_stream_index] : ist;
1696         }
1697     }
1698
1699     /* for each output stream, we compute the right encoding parameters */
1700     for(i=0;i<nb_ostreams;i++) {
1701         ost = ost_table[i];
1702         os = output_files[ost->file_index];
1703         ist = ist_table[ost->source_index];
1704
1705         codec = ost->st->codec;
1706         icodec = ist->st->codec;
1707
1708         if (!ost->st->language[0])
1709             av_strlcpy(ost->st->language, ist->st->language,
1710                        sizeof(ost->st->language));
1711
1712         ost->st->disposition = ist->st->disposition;
1713
1714         if (ost->st->stream_copy) {
1715             /* if stream_copy is selected, no need to decode or encode */
1716             codec->codec_id = icodec->codec_id;
1717             codec->codec_type = icodec->codec_type;
1718
1719             if(!codec->codec_tag){
1720                 if(   !os->oformat->codec_tag
1721                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1722                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1723                     codec->codec_tag = icodec->codec_tag;
1724             }
1725
1726             codec->bit_rate = icodec->bit_rate;
1727             codec->extradata= icodec->extradata;
1728             codec->extradata_size= icodec->extradata_size;
1729             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1730                 codec->time_base = icodec->time_base;
1731             else
1732                 codec->time_base = ist->st->time_base;
1733             switch(codec->codec_type) {
1734             case CODEC_TYPE_AUDIO:
1735                 if(audio_volume != 256) {
1736                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1737                     av_exit(1);
1738                 }
1739                 codec->sample_rate = icodec->sample_rate;
1740                 codec->channels = icodec->channels;
1741                 codec->frame_size = icodec->frame_size;
1742                 codec->block_align= icodec->block_align;
1743                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1744                     codec->block_align= 0;
1745                 if(codec->codec_id == CODEC_ID_AC3)
1746                     codec->block_align= 0;
1747                 break;
1748             case CODEC_TYPE_VIDEO:
1749                 if(using_vhook) {
1750                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1751                     av_exit(1);
1752                 }
1753                 codec->pix_fmt = icodec->pix_fmt;
1754                 codec->width = icodec->width;
1755                 codec->height = icodec->height;
1756                 codec->has_b_frames = icodec->has_b_frames;
1757                 break;
1758             case CODEC_TYPE_SUBTITLE:
1759                 break;
1760             default:
1761                 abort();
1762             }
1763         } else {
1764             switch(codec->codec_type) {
1765             case CODEC_TYPE_AUDIO:
1766                 if (av_fifo_init(&ost->fifo, 1024))
1767                     goto fail;
1768                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1769                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1770                 icodec->request_channels = codec->channels;
1771                 ist->decoding_needed = 1;
1772                 ost->encoding_needed = 1;
1773                 break;
1774             case CODEC_TYPE_VIDEO:
1775                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1776                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1777                 ost->video_resample = ((codec->width != icodec->width -
1778                                 (frame_leftBand + frame_rightBand) +
1779                                 (frame_padleft + frame_padright)) ||
1780                         (codec->height != icodec->height -
1781                                 (frame_topBand  + frame_bottomBand) +
1782                                 (frame_padtop + frame_padbottom)) ||
1783                         (codec->pix_fmt != icodec->pix_fmt));
1784                 if (ost->video_crop) {
1785                     ost->topBand = frame_topBand;
1786                     ost->leftBand = frame_leftBand;
1787                 }
1788                 if (ost->video_pad) {
1789                     ost->padtop = frame_padtop;
1790                     ost->padleft = frame_padleft;
1791                     ost->padbottom = frame_padbottom;
1792                     ost->padright = frame_padright;
1793                     if (!ost->video_resample) {
1794                         avcodec_get_frame_defaults(&ost->pict_tmp);
1795                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1796                                          codec->width, codec->height))
1797                             goto fail;
1798                     }
1799                 }
1800                 if (ost->video_resample) {
1801                     avcodec_get_frame_defaults(&ost->pict_tmp);
1802                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1803                                          codec->width, codec->height)) {
1804                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1805                         av_exit(1);
1806                     }
1807                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1808                     ost->img_resample_ctx = sws_getContext(
1809                             icodec->width - (frame_leftBand + frame_rightBand),
1810                             icodec->height - (frame_topBand + frame_bottomBand),
1811                             icodec->pix_fmt,
1812                             codec->width - (frame_padleft + frame_padright),
1813                             codec->height - (frame_padtop + frame_padbottom),
1814                             codec->pix_fmt,
1815                             sws_flags, NULL, NULL, NULL);
1816                     if (ost->img_resample_ctx == NULL) {
1817                         fprintf(stderr, "Cannot get resampling context\n");
1818                         av_exit(1);
1819                     }
1820                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1821                 }
1822                 ost->encoding_needed = 1;
1823                 ist->decoding_needed = 1;
1824                 break;
1825             case CODEC_TYPE_SUBTITLE:
1826                 ost->encoding_needed = 1;
1827                 ist->decoding_needed = 1;
1828                 break;
1829             default:
1830                 abort();
1831                 break;
1832             }
1833             /* two pass mode */
1834             if (ost->encoding_needed &&
1835                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1836                 char logfilename[1024];
1837                 FILE *f;
1838                 int size;
1839                 char *logbuffer;
1840
1841                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1842                          pass_logfilename ?
1843                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1844                 if (codec->flags & CODEC_FLAG_PASS1) {
1845                     f = fopen(logfilename, "w");
1846                     if (!f) {
1847                         perror(logfilename);
1848                         av_exit(1);
1849                     }
1850                     ost->logfile = f;
1851                 } else {
1852                     /* read the log file */
1853                     f = fopen(logfilename, "r");
1854                     if (!f) {
1855                         perror(logfilename);
1856                         av_exit(1);
1857                     }
1858                     fseek(f, 0, SEEK_END);
1859                     size = ftell(f);
1860                     fseek(f, 0, SEEK_SET);
1861                     logbuffer = av_malloc(size + 1);
1862                     if (!logbuffer) {
1863                         fprintf(stderr, "Could not allocate log buffer\n");
1864                         av_exit(1);
1865                     }
1866                     size = fread(logbuffer, 1, size, f);
1867                     fclose(f);
1868                     logbuffer[size] = '\0';
1869                     codec->stats_in = logbuffer;
1870                 }
1871             }
1872         }
1873         if(codec->codec_type == CODEC_TYPE_VIDEO){
1874             int size= codec->width * codec->height;
1875             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1876         }
1877     }
1878
1879     if (!bit_buffer)
1880         bit_buffer = av_malloc(bit_buffer_size);
1881     if (!bit_buffer)
1882         goto fail;
1883
1884     /* dump the file output parameters - cannot be done before in case
1885        of stream copy */
1886     for(i=0;i<nb_output_files;i++) {
1887         dump_format(output_files[i], i, output_files[i]->filename, 1);
1888     }
1889
1890     /* dump the stream mapping */
1891     if (verbose >= 0) {
1892         fprintf(stderr, "Stream mapping:\n");
1893         for(i=0;i<nb_ostreams;i++) {
1894             ost = ost_table[i];
1895             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1896                     ist_table[ost->source_index]->file_index,
1897                     ist_table[ost->source_index]->index,
1898                     ost->file_index,
1899                     ost->index);
1900             if (ost->sync_ist != ist_table[ost->source_index])
1901                 fprintf(stderr, " [sync #%d.%d]",
1902                         ost->sync_ist->file_index,
1903                         ost->sync_ist->index);
1904             fprintf(stderr, "\n");
1905         }
1906     }
1907
1908     /* open each encoder */
1909     for(i=0;i<nb_ostreams;i++) {
1910         ost = ost_table[i];
1911         if (ost->encoding_needed) {
1912             AVCodec *codec;
1913             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1914             if (!codec) {
1915                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1916                         ost->file_index, ost->index);
1917                 av_exit(1);
1918             }
1919             if (avcodec_open(ost->st->codec, codec) < 0) {
1920                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1921                         ost->file_index, ost->index);
1922                 av_exit(1);
1923             }
1924             extra_size += ost->st->codec->extradata_size;
1925         }
1926     }
1927
1928     /* open each decoder */
1929     for(i=0;i<nb_istreams;i++) {
1930         ist = ist_table[i];
1931         if (ist->decoding_needed) {
1932             AVCodec *codec;
1933             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1934             if (!codec) {
1935                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1936                         ist->st->codec->codec_id, ist->file_index, ist->index);
1937                 av_exit(1);
1938             }
1939             if (avcodec_open(ist->st->codec, codec) < 0) {
1940                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1941                         ist->file_index, ist->index);
1942                 av_exit(1);
1943             }
1944             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1945             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1946         }
1947     }
1948
1949     /* init pts */
1950     for(i=0;i<nb_istreams;i++) {
1951         ist = ist_table[i];
1952         is = input_files[ist->file_index];
1953         ist->pts = 0;
1954         ist->next_pts = AV_NOPTS_VALUE;
1955         ist->is_start = 1;
1956     }
1957
1958     /* set meta data information from input file if required */
1959     for (i=0;i<nb_meta_data_maps;i++) {
1960         AVFormatContext *out_file;
1961         AVFormatContext *in_file;
1962
1963         int out_file_index = meta_data_maps[i].out_file;
1964         int in_file_index = meta_data_maps[i].in_file;
1965         if (out_file_index < 0 || out_file_index >= nb_output_files) {
1966             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1967             ret = AVERROR(EINVAL);
1968             goto fail;
1969         }
1970         if (in_file_index < 0 || in_file_index >= nb_input_files) {
1971             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1972             ret = AVERROR(EINVAL);
1973             goto fail;
1974         }
1975
1976         out_file = output_files[out_file_index];
1977         in_file = input_files[in_file_index];
1978
1979         strcpy(out_file->title, in_file->title);
1980         strcpy(out_file->author, in_file->author);
1981         strcpy(out_file->copyright, in_file->copyright);
1982         strcpy(out_file->comment, in_file->comment);
1983         strcpy(out_file->album, in_file->album);
1984         out_file->year = in_file->year;
1985         out_file->track = in_file->track;
1986         strcpy(out_file->genre, in_file->genre);
1987     }
1988
1989     /* open files and write file headers */
1990     for(i=0;i<nb_output_files;i++) {
1991         os = output_files[i];
1992         if (av_write_header(os) < 0) {
1993             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1994             ret = AVERROR(EINVAL);
1995             goto fail;
1996         }
1997         if (strcmp(output_files[i]->oformat->name, "rtp")) {
1998             want_sdp = 0;
1999         }
2000     }
2001     if (want_sdp) {
2002         print_sdp(output_files, nb_output_files);
2003     }
2004
2005     if (!using_stdin && verbose >= 0) {
2006         fprintf(stderr, "Press [q] to stop encoding\n");
2007         url_set_interrupt_cb(decode_interrupt_cb);
2008     }
2009     term_init();
2010
2011     key = -1;
2012     timer_start = av_gettime();
2013
2014     for(; received_sigterm == 0;) {
2015         int file_index, ist_index;
2016         AVPacket pkt;
2017         double ipts_min;
2018         double opts_min;
2019
2020     redo:
2021         ipts_min= 1e100;
2022         opts_min= 1e100;
2023         /* if 'q' pressed, exits */
2024         if (!using_stdin) {
2025             if (q_pressed)
2026                 break;
2027             /* read_key() returns 0 on EOF */
2028             key = read_key();
2029             if (key == 'q')
2030                 break;
2031         }
2032
2033         /* select the stream that we must read now by looking at the
2034            smallest output pts */
2035         file_index = -1;
2036         for(i=0;i<nb_ostreams;i++) {
2037             double ipts, opts;
2038             ost = ost_table[i];
2039             os = output_files[ost->file_index];
2040             ist = ist_table[ost->source_index];
2041             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2042                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2043             else
2044                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2045             ipts = (double)ist->pts;
2046             if (!file_table[ist->file_index].eof_reached){
2047                 if(ipts < ipts_min) {
2048                     ipts_min = ipts;
2049                     if(input_sync ) file_index = ist->file_index;
2050                 }
2051                 if(opts < opts_min) {
2052                     opts_min = opts;
2053                     if(!input_sync) file_index = ist->file_index;
2054                 }
2055             }
2056             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2057                 file_index= -1;
2058                 break;
2059             }
2060         }
2061         /* if none, if is finished */
2062         if (file_index < 0) {
2063             break;
2064         }
2065
2066         /* finish if recording time exhausted */
2067         if (opts_min >= (recording_time / 1000000.0))
2068             break;
2069
2070         /* finish if limit size exhausted */
2071         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2072             break;
2073
2074         /* read a frame from it and output it in the fifo */
2075         is = input_files[file_index];
2076         if (av_read_frame(is, &pkt) < 0) {
2077             file_table[file_index].eof_reached = 1;
2078             if (opt_shortest)
2079                 break;
2080             else
2081                 continue;
2082         }
2083
2084         if (do_pkt_dump) {
2085             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2086         }
2087         /* the following test is needed in case new streams appear
2088            dynamically in stream : we ignore them */
2089         if (pkt.stream_index >= file_table[file_index].nb_streams)
2090             goto discard_packet;
2091         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2092         ist = ist_table[ist_index];
2093         if (ist->discard)
2094             goto discard_packet;
2095
2096         if (pkt.dts != AV_NOPTS_VALUE)
2097             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2098         if (pkt.pts != AV_NOPTS_VALUE)
2099             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2100
2101         if(input_files_ts_scale[file_index][pkt.stream_index]){
2102             if(pkt.pts != AV_NOPTS_VALUE)
2103                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2104             if(pkt.dts != AV_NOPTS_VALUE)
2105                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2106         }
2107
2108 //        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);
2109         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2110             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2111             int64_t delta= pkt_dts - ist->next_pts;
2112             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2113                 input_files_ts_offset[ist->file_index]-= delta;
2114                 if (verbose > 2)
2115                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2116                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2117                 if(pkt.pts != AV_NOPTS_VALUE)
2118                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2119             }
2120         }
2121
2122         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2123         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2124
2125             if (verbose >= 0)
2126                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2127                         ist->file_index, ist->index);
2128
2129             av_free_packet(&pkt);
2130             goto redo;
2131         }
2132
2133     discard_packet:
2134         av_free_packet(&pkt);
2135
2136         /* dump report by using the output first video and audio streams */
2137         print_report(output_files, ost_table, nb_ostreams, 0);
2138     }
2139
2140     /* at the end of stream, we must flush the decoder buffers */
2141     for(i=0;i<nb_istreams;i++) {
2142         ist = ist_table[i];
2143         if (ist->decoding_needed) {
2144             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2145         }
2146     }
2147
2148     term_exit();
2149
2150     /* write the trailer if needed and close file */
2151     for(i=0;i<nb_output_files;i++) {
2152         os = output_files[i];
2153         av_write_trailer(os);
2154     }
2155
2156     /* dump report by using the first video and audio streams */
2157     print_report(output_files, ost_table, nb_ostreams, 1);
2158
2159     /* close each encoder */
2160     for(i=0;i<nb_ostreams;i++) {
2161         ost = ost_table[i];
2162         if (ost->encoding_needed) {
2163             av_freep(&ost->st->codec->stats_in);
2164             avcodec_close(ost->st->codec);
2165         }
2166     }
2167
2168     /* close each decoder */
2169     for(i=0;i<nb_istreams;i++) {
2170         ist = ist_table[i];
2171         if (ist->decoding_needed) {
2172             avcodec_close(ist->st->codec);
2173         }
2174     }
2175
2176     /* finished ! */
2177
2178     ret = 0;
2179  fail1:
2180     av_freep(&bit_buffer);
2181     av_free(file_table);
2182
2183     if (ist_table) {
2184         for(i=0;i<nb_istreams;i++) {
2185             ist = ist_table[i];
2186             av_free(ist);
2187         }
2188         av_free(ist_table);
2189     }
2190     if (ost_table) {
2191         for(i=0;i<nb_ostreams;i++) {
2192             ost = ost_table[i];
2193             if (ost) {
2194                 if (ost->logfile) {
2195                     fclose(ost->logfile);
2196                     ost->logfile = NULL;
2197                 }
2198                 av_fifo_free(&ost->fifo); /* works even if fifo is not
2199                                              initialized but set to zero */
2200                 av_free(ost->pict_tmp.data[0]);
2201                 if (ost->video_resample)
2202                     sws_freeContext(ost->img_resample_ctx);
2203                 if (ost->resample)
2204                     audio_resample_close(ost->resample);
2205                 if (ost->reformat_ctx)
2206                     av_audio_convert_free(ost->reformat_ctx);
2207                 av_free(ost);
2208             }
2209         }
2210         av_free(ost_table);
2211     }
2212     return ret;
2213  fail:
2214     ret = AVERROR(ENOMEM);
2215     goto fail1;
2216 }
2217
2218 #if 0
2219 int file_read(const char *filename)
2220 {
2221     URLContext *h;
2222     unsigned char buffer[1024];
2223     int len, i;
2224
2225     if (url_open(&h, filename, O_RDONLY) < 0) {
2226         printf("could not open '%s'\n", filename);
2227         return -1;
2228     }
2229     for(;;) {
2230         len = url_read(h, buffer, sizeof(buffer));
2231         if (len <= 0)
2232             break;
2233         for(i=0;i<len;i++) putchar(buffer[i]);
2234     }
2235     url_close(h);
2236     return 0;
2237 }
2238 #endif
2239
2240 static void opt_format(const char *arg)
2241 {
2242     /* compatibility stuff for pgmyuv */
2243     if (!strcmp(arg, "pgmyuv")) {
2244         pgmyuv_compatibility_hack=1;
2245 //        opt_image_format(arg);
2246         arg = "image2";
2247         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2248     }
2249
2250     file_iformat = av_find_input_format(arg);
2251     file_oformat = guess_format(arg, NULL, NULL);
2252     if (!file_iformat && !file_oformat) {
2253         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2254         av_exit(1);
2255     }
2256 }
2257
2258 static int opt_default(const char *opt, const char *arg){
2259     int type;
2260     const AVOption *o= NULL;
2261     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2262
2263     for(type=0; type<CODEC_TYPE_NB; type++){
2264         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2265         if(o2)
2266             o = av_set_string2(avctx_opts[type], opt, arg, 1);
2267     }
2268     if(!o)
2269         o = av_set_string2(avformat_opts, opt, arg, 1);
2270     if(!o)
2271         o = av_set_string2(sws_opts, opt, arg, 1);
2272     if(!o){
2273         if(opt[0] == 'a')
2274             o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2275         else if(opt[0] == 'v')
2276             o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2277         else if(opt[0] == 's')
2278             o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2279     }
2280     if(!o)
2281         return -1;
2282
2283 //    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));
2284
2285     //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
2286     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2287     opt_names[opt_name_count++]= o->name;
2288
2289     if(avctx_opts[0]->debug || avformat_opts->debug)
2290         av_log_set_level(AV_LOG_DEBUG);
2291     return 0;
2292 }
2293
2294 static void opt_video_rc_override_string(const char *arg)
2295 {
2296     video_rc_override_string = arg;
2297 }
2298
2299 static int opt_me_threshold(const char *opt, const char *arg)
2300 {
2301     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2302     return 0;
2303 }
2304
2305 static int opt_verbose(const char *opt, const char *arg)
2306 {
2307     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2308     av_log_set_level(verbose);
2309     return 0;
2310 }
2311
2312 static void opt_frame_rate(const char *arg)
2313 {
2314     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2315         fprintf(stderr, "Incorrect frame rate\n");
2316         av_exit(1);
2317     }
2318 }
2319
2320 static int opt_bitrate(const char *opt, const char *arg)
2321 {
2322     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2323
2324     opt_default(opt, arg);
2325
2326     if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2327         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2328
2329     return 0;
2330 }
2331
2332 static void opt_frame_crop_top(const char *arg)
2333 {
2334     frame_topBand = atoi(arg);
2335     if (frame_topBand < 0) {
2336         fprintf(stderr, "Incorrect top crop size\n");
2337         av_exit(1);
2338     }
2339     if ((frame_topBand % 2) != 0) {
2340         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2341         av_exit(1);
2342     }
2343     if ((frame_topBand) >= frame_height){
2344         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2345         av_exit(1);
2346     }
2347     frame_height -= frame_topBand;
2348 }
2349
2350 static void opt_frame_crop_bottom(const char *arg)
2351 {
2352     frame_bottomBand = atoi(arg);
2353     if (frame_bottomBand < 0) {
2354         fprintf(stderr, "Incorrect bottom crop size\n");
2355         av_exit(1);
2356     }
2357     if ((frame_bottomBand % 2) != 0) {
2358         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2359         av_exit(1);
2360     }
2361     if ((frame_bottomBand) >= frame_height){
2362         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2363         av_exit(1);
2364     }
2365     frame_height -= frame_bottomBand;
2366 }
2367
2368 static void opt_frame_crop_left(const char *arg)
2369 {
2370     frame_leftBand = atoi(arg);
2371     if (frame_leftBand < 0) {
2372         fprintf(stderr, "Incorrect left crop size\n");
2373         av_exit(1);
2374     }
2375     if ((frame_leftBand % 2) != 0) {
2376         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2377         av_exit(1);
2378     }
2379     if ((frame_leftBand) >= frame_width){
2380         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2381         av_exit(1);
2382     }
2383     frame_width -= frame_leftBand;
2384 }
2385
2386 static void opt_frame_crop_right(const char *arg)
2387 {
2388     frame_rightBand = atoi(arg);
2389     if (frame_rightBand < 0) {
2390         fprintf(stderr, "Incorrect right crop size\n");
2391         av_exit(1);
2392     }
2393     if ((frame_rightBand % 2) != 0) {
2394         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2395         av_exit(1);
2396     }
2397     if ((frame_rightBand) >= frame_width){
2398         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2399         av_exit(1);
2400     }
2401     frame_width -= frame_rightBand;
2402 }
2403
2404 static void opt_frame_size(const char *arg)
2405 {
2406     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2407         fprintf(stderr, "Incorrect frame size\n");
2408         av_exit(1);
2409     }
2410     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2411         fprintf(stderr, "Frame size must be a multiple of 2\n");
2412         av_exit(1);
2413     }
2414 }
2415
2416
2417 #define SCALEBITS 10
2418 #define ONE_HALF  (1 << (SCALEBITS - 1))
2419 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2420
2421 #define RGB_TO_Y(r, g, b) \
2422 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2423   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2424
2425 #define RGB_TO_U(r1, g1, b1, shift)\
2426 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2427      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2428
2429 #define RGB_TO_V(r1, g1, b1, shift)\
2430 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2431    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2432
2433 static void opt_pad_color(const char *arg) {
2434     /* Input is expected to be six hex digits similar to
2435        how colors are expressed in html tags (but without the #) */
2436     int rgb = strtol(arg, NULL, 16);
2437     int r,g,b;
2438
2439     r = (rgb >> 16);
2440     g = ((rgb >> 8) & 255);
2441     b = (rgb & 255);
2442
2443     padcolor[0] = RGB_TO_Y(r,g,b);
2444     padcolor[1] = RGB_TO_U(r,g,b,0);
2445     padcolor[2] = RGB_TO_V(r,g,b,0);
2446 }
2447
2448 static void opt_frame_pad_top(const char *arg)
2449 {
2450     frame_padtop = atoi(arg);
2451     if (frame_padtop < 0) {
2452         fprintf(stderr, "Incorrect top pad size\n");
2453         av_exit(1);
2454     }
2455     if ((frame_padtop % 2) != 0) {
2456         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2457         av_exit(1);
2458     }
2459 }
2460
2461 static void opt_frame_pad_bottom(const char *arg)
2462 {
2463     frame_padbottom = atoi(arg);
2464     if (frame_padbottom < 0) {
2465         fprintf(stderr, "Incorrect bottom pad size\n");
2466         av_exit(1);
2467     }
2468     if ((frame_padbottom % 2) != 0) {
2469         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2470         av_exit(1);
2471     }
2472 }
2473
2474
2475 static void opt_frame_pad_left(const char *arg)
2476 {
2477     frame_padleft = atoi(arg);
2478     if (frame_padleft < 0) {
2479         fprintf(stderr, "Incorrect left pad size\n");
2480         av_exit(1);
2481     }
2482     if ((frame_padleft % 2) != 0) {
2483         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2484         av_exit(1);
2485     }
2486 }
2487
2488
2489 static void opt_frame_pad_right(const char *arg)
2490 {
2491     frame_padright = atoi(arg);
2492     if (frame_padright < 0) {
2493         fprintf(stderr, "Incorrect right pad size\n");
2494         av_exit(1);
2495     }
2496     if ((frame_padright % 2) != 0) {
2497         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2498         av_exit(1);
2499     }
2500 }
2501
2502 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2503 {
2504     int i;
2505     char fmt_str[128];
2506     for (i=-1; i < nb_fmts; i++) {
2507         get_fmt_string (fmt_str, sizeof(fmt_str), i);
2508         fprintf(stdout, "%s\n", fmt_str);
2509     }
2510 }
2511
2512 static void opt_frame_pix_fmt(const char *arg)
2513 {
2514     if (strcmp(arg, "list"))
2515         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2516     else {
2517         list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2518         av_exit(0);
2519     }
2520 }
2521
2522 static void opt_frame_aspect_ratio(const char *arg)
2523 {
2524     int x = 0, y = 0;
2525     double ar = 0;
2526     const char *p;
2527     char *end;
2528
2529     p = strchr(arg, ':');
2530     if (p) {
2531         x = strtol(arg, &end, 10);
2532         if (end == p)
2533             y = strtol(end+1, &end, 10);
2534         if (x > 0 && y > 0)
2535             ar = (double)x / (double)y;
2536     } else
2537         ar = strtod(arg, NULL);
2538
2539     if (!ar) {
2540         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2541         av_exit(1);
2542     }
2543     frame_aspect_ratio = ar;
2544 }
2545
2546 static void opt_qscale(const char *arg)
2547 {
2548     video_qscale = atof(arg);
2549     if (video_qscale <= 0 ||
2550         video_qscale > 255) {
2551         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2552         av_exit(1);
2553     }
2554 }
2555
2556 static void opt_top_field_first(const char *arg)
2557 {
2558     top_field_first= atoi(arg);
2559 }
2560
2561 static int opt_thread_count(const char *opt, const char *arg)
2562 {
2563     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2564 #if !defined(HAVE_THREADS)
2565     if (verbose >= 0)
2566         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2567 #endif
2568     return 0;
2569 }
2570
2571 static void opt_audio_sample_fmt(const char *arg)
2572 {
2573     if (strcmp(arg, "list"))
2574         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2575     else {
2576         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2577         av_exit(0);
2578     }
2579 }
2580
2581 static int opt_audio_rate(const char *opt, const char *arg)
2582 {
2583     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2584     return 0;
2585 }
2586
2587 static int opt_audio_channels(const char *opt, const char *arg)
2588 {
2589     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2590     return 0;
2591 }
2592
2593 static void opt_video_channel(const char *arg)
2594 {
2595     video_channel = strtol(arg, NULL, 0);
2596 }
2597
2598 static void opt_video_standard(const char *arg)
2599 {
2600     video_standard = av_strdup(arg);
2601 }
2602
2603 static void opt_codec(int *pstream_copy, char **pcodec_name,
2604                       int codec_type, const char *arg)
2605 {
2606     av_freep(pcodec_name);
2607     if (!strcmp(arg, "copy")) {
2608         *pstream_copy = 1;
2609     } else {
2610         *pcodec_name = av_strdup(arg);
2611     }
2612 }
2613
2614 static void opt_audio_codec(const char *arg)
2615 {
2616     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2617 }
2618
2619 static void opt_audio_tag(const char *arg)
2620 {
2621     char *tail;
2622     audio_codec_tag= strtol(arg, &tail, 0);
2623
2624     if(!tail || *tail)
2625         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2626 }
2627
2628 static void opt_video_tag(const char *arg)
2629 {
2630     char *tail;
2631     video_codec_tag= strtol(arg, &tail, 0);
2632
2633     if(!tail || *tail)
2634         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2635 }
2636
2637 #ifdef CONFIG_VHOOK
2638 static void add_frame_hooker(const char *arg)
2639 {
2640     int argc = 0;
2641     char *argv[64];
2642     int i;
2643     char *args = av_strdup(arg);
2644
2645     using_vhook = 1;
2646
2647     argv[0] = strtok(args, " ");
2648     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2649     }
2650
2651     i = frame_hook_add(argc, argv);
2652
2653     if (i != 0) {
2654         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2655         av_exit(1);
2656     }
2657 }
2658 #endif
2659
2660 static void opt_video_codec(const char *arg)
2661 {
2662     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2663 }
2664
2665 static void opt_subtitle_codec(const char *arg)
2666 {
2667     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2668 }
2669
2670 static void opt_map(const char *arg)
2671 {
2672     AVStreamMap *m;
2673     char *p;
2674
2675     m = &stream_maps[nb_stream_maps++];
2676
2677     m->file_index = strtol(arg, &p, 0);
2678     if (*p)
2679         p++;
2680
2681     m->stream_index = strtol(p, &p, 0);
2682     if (*p) {
2683         p++;
2684         m->sync_file_index = strtol(p, &p, 0);
2685         if (*p)
2686             p++;
2687         m->sync_stream_index = strtol(p, &p, 0);
2688     } else {
2689         m->sync_file_index = m->file_index;
2690         m->sync_stream_index = m->stream_index;
2691     }
2692 }
2693
2694 static void opt_map_meta_data(const char *arg)
2695 {
2696     AVMetaDataMap *m;
2697     char *p;
2698
2699     m = &meta_data_maps[nb_meta_data_maps++];
2700
2701     m->out_file = strtol(arg, &p, 0);
2702     if (*p)
2703         p++;
2704
2705     m->in_file = strtol(p, &p, 0);
2706 }
2707
2708 static void opt_input_ts_scale(const char *arg)
2709 {
2710     unsigned int stream;
2711     double scale;
2712     char *p;
2713
2714     stream = strtol(arg, &p, 0);
2715     if (*p)
2716         p++;
2717     scale= strtod(p, &p);
2718
2719     if(stream >= MAX_STREAMS)
2720         av_exit(1);
2721
2722     input_files_ts_scale[nb_input_files][stream]= scale;
2723 }
2724
2725 static int opt_recording_time(const char *opt, const char *arg)
2726 {
2727     recording_time = parse_time_or_die(opt, arg, 1);
2728     return 0;
2729 }
2730
2731 static int opt_start_time(const char *opt, const char *arg)
2732 {
2733     start_time = parse_time_or_die(opt, arg, 1);
2734     return 0;
2735 }
2736
2737 static int opt_rec_timestamp(const char *opt, const char *arg)
2738 {
2739     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2740     return 0;
2741 }
2742
2743 static int opt_input_ts_offset(const char *opt, const char *arg)
2744 {
2745     input_ts_offset = parse_time_or_die(opt, arg, 1);
2746     return 0;
2747 }
2748
2749 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2750 {
2751     const char *codec_string = encoder ? "encoder" : "decoder";
2752     AVCodec *codec;
2753
2754     if(!name)
2755         return CODEC_ID_NONE;
2756     codec = encoder ?
2757         avcodec_find_encoder_by_name(name) :
2758         avcodec_find_decoder_by_name(name);
2759     if(!codec) {
2760         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2761         av_exit(1);
2762     }
2763     if(codec->type != type) {
2764         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2765         av_exit(1);
2766     }
2767     return codec->id;
2768 }
2769
2770 static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2771 {
2772     int i;
2773     for(i=0; i<opt_name_count; i++){
2774         char buf[256];
2775         const AVOption *opt;
2776         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2777         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2778         if(str && ((opt->flags & flags) == flags))
2779             av_set_string2(ctx, opt_names[i], str, 1);
2780     }
2781 }
2782
2783 static void opt_input_file(const char *filename)
2784 {
2785     AVFormatContext *ic;
2786     AVFormatParameters params, *ap = &params;
2787     int err, i, ret, rfps, rfps_base;
2788     int64_t timestamp;
2789
2790     if (!strcmp(filename, "-"))
2791         filename = "pipe:";
2792
2793     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2794                     !strcmp(filename, "/dev/stdin");
2795
2796     /* get default parameters from command line */
2797     ic = av_alloc_format_context();
2798
2799     memset(ap, 0, sizeof(*ap));
2800     ap->prealloced_context = 1;
2801     ap->sample_rate = audio_sample_rate;
2802     ap->channels = audio_channels;
2803     ap->time_base.den = frame_rate.num;
2804     ap->time_base.num = frame_rate.den;
2805     ap->width = frame_width + frame_padleft + frame_padright;
2806     ap->height = frame_height + frame_padtop + frame_padbottom;
2807     ap->pix_fmt = frame_pix_fmt;
2808    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2809     ap->channel = video_channel;
2810     ap->standard = video_standard;
2811     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2812     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2813     if(pgmyuv_compatibility_hack)
2814         ap->video_codec_id= CODEC_ID_PGMYUV;
2815
2816     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2817
2818     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2819     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2820     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2821
2822     /* open the input file with generic libav function */
2823     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2824     if (err < 0) {
2825         print_error(filename, err);
2826         av_exit(1);
2827     }
2828     if(opt_programid) {
2829         int i;
2830         for(i=0; i<ic->nb_programs; i++)
2831             if(ic->programs[i]->id != opt_programid)
2832                 ic->programs[i]->discard = AVDISCARD_ALL;
2833     }
2834
2835     ic->loop_input = loop_input;
2836
2837     /* If not enough info to get the stream parameters, we decode the
2838        first frames to get it. (used in mpeg case for example) */
2839     ret = av_find_stream_info(ic);
2840     if (ret < 0 && verbose >= 0) {
2841         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2842         av_exit(1);
2843     }
2844
2845     timestamp = start_time;
2846     /* add the stream start time */
2847     if (ic->start_time != AV_NOPTS_VALUE)
2848         timestamp += ic->start_time;
2849
2850     /* if seeking requested, we execute it */
2851     if (start_time != 0) {
2852         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2853         if (ret < 0) {
2854             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2855                     filename, (double)timestamp / AV_TIME_BASE);
2856         }
2857         /* reset seek info */
2858         start_time = 0;
2859     }
2860
2861     /* update the current parameters so that they match the one of the input stream */
2862     for(i=0;i<ic->nb_streams;i++) {
2863         AVCodecContext *enc = ic->streams[i]->codec;
2864         if(thread_count>1)
2865             avcodec_thread_init(enc, thread_count);
2866         enc->thread_count= thread_count;
2867         switch(enc->codec_type) {
2868         case CODEC_TYPE_AUDIO:
2869             set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2870             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2871             audio_channels = enc->channels;
2872             audio_sample_rate = enc->sample_rate;
2873             audio_sample_fmt = enc->sample_fmt;
2874             if(audio_disable)
2875                 ic->streams[i]->discard= AVDISCARD_ALL;
2876             break;
2877         case CODEC_TYPE_VIDEO:
2878             set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2879             frame_height = enc->height;
2880             frame_width = enc->width;
2881             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2882             frame_pix_fmt = enc->pix_fmt;
2883             rfps      = ic->streams[i]->r_frame_rate.num;
2884             rfps_base = ic->streams[i]->r_frame_rate.den;
2885             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2886             if(me_threshold)
2887                 enc->debug |= FF_DEBUG_MV;
2888
2889             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2890
2891                 if (verbose >= 0)
2892                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2893                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2894
2895                     (float)rfps / rfps_base, rfps, rfps_base);
2896             }
2897             /* update the current frame rate to match the stream frame rate */
2898             frame_rate.num = rfps;
2899             frame_rate.den = rfps_base;
2900
2901             enc->rate_emu = rate_emu;
2902             if(video_disable)
2903                 ic->streams[i]->discard= AVDISCARD_ALL;
2904             else if(video_discard)
2905                 ic->streams[i]->discard= video_discard;
2906             break;
2907         case CODEC_TYPE_DATA:
2908             break;
2909         case CODEC_TYPE_SUBTITLE:
2910             if(subtitle_disable)
2911                 ic->streams[i]->discard = AVDISCARD_ALL;
2912             break;
2913         case CODEC_TYPE_ATTACHMENT:
2914         case CODEC_TYPE_UNKNOWN:
2915             break;
2916         default:
2917             abort();
2918         }
2919     }
2920
2921     input_files[nb_input_files] = ic;
2922     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2923     /* dump the file content */
2924     if (verbose >= 0)
2925         dump_format(ic, nb_input_files, filename, 0);
2926
2927     nb_input_files++;
2928     file_iformat = NULL;
2929     file_oformat = NULL;
2930
2931     video_channel = 0;
2932
2933     rate_emu = 0;
2934     av_freep(&video_codec_name);
2935     av_freep(&audio_codec_name);
2936     av_freep(&subtitle_codec_name);
2937 }
2938
2939 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2940                                          int *has_subtitle_ptr)
2941 {
2942     int has_video, has_audio, has_subtitle, i, j;
2943     AVFormatContext *ic;
2944
2945     has_video = 0;
2946     has_audio = 0;
2947     has_subtitle = 0;
2948     for(j=0;j<nb_input_files;j++) {
2949         ic = input_files[j];
2950         for(i=0;i<ic->nb_streams;i++) {
2951             AVCodecContext *enc = ic->streams[i]->codec;
2952             switch(enc->codec_type) {
2953             case CODEC_TYPE_AUDIO:
2954                 has_audio = 1;
2955                 break;
2956             case CODEC_TYPE_VIDEO:
2957                 has_video = 1;
2958                 break;
2959             case CODEC_TYPE_SUBTITLE:
2960                 has_subtitle = 1;
2961                 break;
2962             case CODEC_TYPE_DATA:
2963             case CODEC_TYPE_ATTACHMENT:
2964             case CODEC_TYPE_UNKNOWN:
2965                 break;
2966             default:
2967                 abort();
2968             }
2969         }
2970     }
2971     *has_video_ptr = has_video;
2972     *has_audio_ptr = has_audio;
2973     *has_subtitle_ptr = has_subtitle;
2974 }
2975
2976 static void new_video_stream(AVFormatContext *oc)
2977 {
2978     AVStream *st;
2979     AVCodecContext *video_enc;
2980     int codec_id;
2981
2982     st = av_new_stream(oc, oc->nb_streams);
2983     if (!st) {
2984         fprintf(stderr, "Could not alloc stream\n");
2985         av_exit(1);
2986     }
2987     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2988     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2989     video_bitstream_filters= NULL;
2990
2991     if(thread_count>1)
2992         avcodec_thread_init(st->codec, thread_count);
2993
2994     video_enc = st->codec;
2995
2996     if(video_codec_tag)
2997         video_enc->codec_tag= video_codec_tag;
2998
2999     if(   (video_global_header&1)
3000        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3001         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3002         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3003     }
3004     if(video_global_header&2){
3005         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3006         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3007     }
3008
3009     if (video_stream_copy) {
3010         st->stream_copy = 1;
3011         video_enc->codec_type = CODEC_TYPE_VIDEO;
3012     } else {
3013         const char *p;
3014         int i;
3015         AVCodec *codec;
3016         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3017
3018         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3019         if (video_codec_name)
3020             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3021
3022         video_enc->codec_id = codec_id;
3023         codec = avcodec_find_encoder(codec_id);
3024
3025         set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3026
3027         video_enc->time_base.den = fps.num;
3028         video_enc->time_base.num = fps.den;
3029         if(codec && codec->supported_framerates){
3030             const AVRational *p= codec->supported_framerates;
3031             const AVRational *best=NULL;
3032             AVRational best_error= (AVRational){INT_MAX, 1};
3033             for(; p->den!=0; p++){
3034                 AVRational error= av_sub_q(fps, *p);
3035                 if(error.num <0) error.num *= -1;
3036                 if(av_cmp_q(error, best_error) < 0){
3037                     best_error= error;
3038                     best= p;
3039                 }
3040             }
3041             video_enc->time_base.den= best->num;
3042             video_enc->time_base.num= best->den;
3043         }
3044
3045         video_enc->width = frame_width + frame_padright + frame_padleft;
3046         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3047         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3048         video_enc->pix_fmt = frame_pix_fmt;
3049
3050         if(codec && codec->pix_fmts){
3051             const enum PixelFormat *p= codec->pix_fmts;
3052             for(; *p!=-1; p++){
3053                 if(*p == video_enc->pix_fmt)
3054                     break;
3055             }
3056             if(*p == -1)
3057                 video_enc->pix_fmt = codec->pix_fmts[0];
3058         }
3059
3060         if (intra_only)
3061             video_enc->gop_size = 0;
3062         if (video_qscale || same_quality) {
3063             video_enc->flags |= CODEC_FLAG_QSCALE;
3064             video_enc->global_quality=
3065                 st->quality = FF_QP2LAMBDA * video_qscale;
3066         }
3067
3068         if(intra_matrix)
3069             video_enc->intra_matrix = intra_matrix;
3070         if(inter_matrix)
3071             video_enc->inter_matrix = inter_matrix;
3072
3073         video_enc->thread_count = thread_count;
3074         p= video_rc_override_string;
3075         for(i=0; p; i++){
3076             int start, end, q;
3077             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3078             if(e!=3){
3079                 fprintf(stderr, "error parsing rc_override\n");
3080                 av_exit(1);
3081             }
3082             video_enc->rc_override=
3083                 av_realloc(video_enc->rc_override,
3084                            sizeof(RcOverride)*(i+1));
3085             video_enc->rc_override[i].start_frame= start;
3086             video_enc->rc_override[i].end_frame  = end;
3087             if(q>0){
3088                 video_enc->rc_override[i].qscale= q;
3089                 video_enc->rc_override[i].quality_factor= 1.0;
3090             }
3091             else{
3092                 video_enc->rc_override[i].qscale= 0;
3093                 video_enc->rc_override[i].quality_factor= -q/100.0;
3094             }
3095             p= strchr(p, '/');
3096             if(p) p++;
3097         }
3098         video_enc->rc_override_count=i;
3099         if (!video_enc->rc_initial_buffer_occupancy)
3100             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3101         video_enc->me_threshold= me_threshold;
3102         video_enc->intra_dc_precision= intra_dc_precision - 8;
3103
3104         if (do_psnr)
3105             video_enc->flags|= CODEC_FLAG_PSNR;
3106
3107         /* two pass mode */
3108         if (do_pass) {
3109             if (do_pass == 1) {
3110                 video_enc->flags |= CODEC_FLAG_PASS1;
3111             } else {
3112                 video_enc->flags |= CODEC_FLAG_PASS2;
3113             }
3114         }
3115     }
3116
3117     /* reset some key parameters */
3118     video_disable = 0;
3119     av_freep(&video_codec_name);
3120     video_stream_copy = 0;
3121 }
3122
3123 static void new_audio_stream(AVFormatContext *oc)
3124 {
3125     AVStream *st;
3126     AVCodecContext *audio_enc;
3127     int codec_id;
3128
3129     st = av_new_stream(oc, oc->nb_streams);
3130     if (!st) {
3131         fprintf(stderr, "Could not alloc stream\n");
3132         av_exit(1);
3133     }
3134     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3135
3136     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3137     audio_bitstream_filters= NULL;
3138
3139     if(thread_count>1)
3140         avcodec_thread_init(st->codec, thread_count);
3141
3142     audio_enc = st->codec;
3143     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3144
3145     if(audio_codec_tag)
3146         audio_enc->codec_tag= audio_codec_tag;
3147
3148     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3149         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3150         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3151     }
3152     if (audio_stream_copy) {
3153         st->stream_copy = 1;
3154         audio_enc->channels = audio_channels;
3155     } else {
3156         AVCodec *codec;
3157         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3158
3159         set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3160
3161         if (audio_codec_name)
3162             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3163         audio_enc->codec_id = codec_id;
3164         codec = avcodec_find_encoder(codec_id);
3165
3166         if (audio_qscale > QSCALE_NONE) {
3167             audio_enc->flags |= CODEC_FLAG_QSCALE;
3168             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3169         }
3170         audio_enc->thread_count = thread_count;
3171         audio_enc->channels = audio_channels;
3172         audio_enc->sample_fmt = audio_sample_fmt;
3173
3174         if(codec && codec->sample_fmts){
3175             const enum SampleFormat *p= codec->sample_fmts;
3176             for(; *p!=-1; p++){
3177                 if(*p == audio_enc->sample_fmt)
3178                     break;
3179             }
3180             if(*p == -1)
3181                 audio_enc->sample_fmt = codec->sample_fmts[0];
3182         }
3183     }
3184     audio_enc->sample_rate = audio_sample_rate;
3185     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3186     if (audio_language) {
3187         av_strlcpy(st->language, audio_language, sizeof(st->language));
3188         av_free(audio_language);
3189         audio_language = NULL;
3190     }
3191
3192     /* reset some key parameters */
3193     audio_disable = 0;
3194     av_freep(&audio_codec_name);
3195     audio_stream_copy = 0;
3196 }
3197
3198 static void new_subtitle_stream(AVFormatContext *oc)
3199 {
3200     AVStream *st;
3201     AVCodecContext *subtitle_enc;
3202
3203     st = av_new_stream(oc, oc->nb_streams);
3204     if (!st) {
3205         fprintf(stderr, "Could not alloc stream\n");
3206         av_exit(1);
3207     }
3208     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3209
3210     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3211     subtitle_bitstream_filters= NULL;
3212
3213     subtitle_enc = st->codec;
3214     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3215     if (subtitle_stream_copy) {
3216         st->stream_copy = 1;
3217     } else {
3218         set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3219         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3220     }
3221
3222     if (subtitle_language) {
3223         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3224         av_free(subtitle_language);
3225         subtitle_language = NULL;
3226     }
3227
3228     subtitle_disable = 0;
3229     av_freep(&subtitle_codec_name);
3230     subtitle_stream_copy = 0;
3231 }
3232
3233 static void opt_new_audio_stream(void)
3234 {
3235     AVFormatContext *oc;
3236     if (nb_output_files <= 0) {
3237         fprintf(stderr, "At least one output file must be specified\n");
3238         av_exit(1);
3239     }
3240     oc = output_files[nb_output_files - 1];
3241     new_audio_stream(oc);
3242 }
3243
3244 static void opt_new_video_stream(void)
3245 {
3246     AVFormatContext *oc;
3247     if (nb_output_files <= 0) {
3248         fprintf(stderr, "At least one output file must be specified\n");
3249         av_exit(1);
3250     }
3251     oc = output_files[nb_output_files - 1];
3252     new_video_stream(oc);
3253 }
3254
3255 static void opt_new_subtitle_stream(void)
3256 {
3257     AVFormatContext *oc;
3258     if (nb_output_files <= 0) {
3259         fprintf(stderr, "At least one output file must be specified\n");
3260         av_exit(1);
3261     }
3262     oc = output_files[nb_output_files - 1];
3263     new_subtitle_stream(oc);
3264 }
3265
3266 static void opt_output_file(const char *filename)
3267 {
3268     AVFormatContext *oc;
3269     int use_video, use_audio, use_subtitle;
3270     int input_has_video, input_has_audio, input_has_subtitle;
3271     AVFormatParameters params, *ap = &params;
3272
3273     if (!strcmp(filename, "-"))
3274         filename = "pipe:";
3275
3276     oc = av_alloc_format_context();
3277
3278     if (!file_oformat) {
3279         file_oformat = guess_format(NULL, filename, NULL);
3280         if (!file_oformat) {
3281             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3282                     filename);
3283             av_exit(1);
3284         }
3285     }
3286
3287     oc->oformat = file_oformat;
3288     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3289
3290     if (!strcmp(file_oformat->name, "ffm") &&
3291         av_strstart(filename, "http:", NULL)) {
3292         /* special case for files sent to ffserver: we get the stream
3293            parameters from ffserver */
3294         int err = read_ffserver_streams(oc, filename);
3295         if (err < 0) {
3296             print_error(filename, err);
3297             av_exit(1);
3298         }
3299     } else {
3300         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3301         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3302         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3303
3304         /* disable if no corresponding type found and at least one
3305            input file */
3306         if (nb_input_files > 0) {
3307             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3308                                          &input_has_subtitle);
3309             if (!input_has_video)
3310                 use_video = 0;
3311             if (!input_has_audio)
3312                 use_audio = 0;
3313             if (!input_has_subtitle)
3314                 use_subtitle = 0;
3315         }
3316
3317         /* manual disable */
3318         if (audio_disable) {
3319             use_audio = 0;
3320         }
3321         if (video_disable) {
3322             use_video = 0;
3323         }
3324         if (subtitle_disable) {
3325             use_subtitle = 0;
3326         }
3327
3328         if (use_video) {
3329             new_video_stream(oc);
3330         }
3331
3332         if (use_audio) {
3333             new_audio_stream(oc);
3334         }
3335
3336         if (use_subtitle) {
3337             new_subtitle_stream(oc);
3338         }
3339
3340         oc->timestamp = rec_timestamp;
3341
3342         if (str_title)
3343             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3344         if (str_author)
3345             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3346         if (str_copyright)
3347             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3348         if (str_comment)
3349             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3350         if (str_album)
3351             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3352         if (str_genre)
3353             av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3354     }
3355
3356     output_files[nb_output_files++] = oc;
3357
3358     /* check filename in case of an image number is expected */
3359     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3360         if (!av_filename_number_test(oc->filename)) {
3361             print_error(oc->filename, AVERROR_NUMEXPECTED);
3362             av_exit(1);
3363         }
3364     }
3365
3366     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3367         /* test if it already exists to avoid loosing precious files */
3368         if (!file_overwrite &&
3369             (strchr(filename, ':') == NULL ||
3370              filename[1] == ':' ||
3371              av_strstart(filename, "file:", NULL))) {
3372             if (url_exist(filename)) {
3373                 int c;
3374
3375                 if (!using_stdin) {
3376                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3377                     fflush(stderr);
3378                     c = getchar();
3379                     if (toupper(c) != 'Y') {
3380                         fprintf(stderr, "Not overwriting - exiting\n");
3381                         av_exit(1);
3382                     }
3383                 }
3384                 else {
3385                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3386                     av_exit(1);
3387                 }
3388             }
3389         }
3390
3391         /* open the file */
3392         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3393             fprintf(stderr, "Could not open '%s'\n", filename);
3394             av_exit(1);
3395         }
3396     }
3397
3398     memset(ap, 0, sizeof(*ap));
3399     if (av_set_parameters(oc, ap) < 0) {
3400         fprintf(stderr, "%s: Invalid encoding parameters\n",
3401                 oc->filename);
3402         av_exit(1);
3403     }
3404
3405     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3406     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3407     oc->loop_output = loop_output;
3408
3409     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3410
3411     /* reset some options */
3412     file_oformat = NULL;
3413     file_iformat = NULL;
3414 }
3415
3416 /* same option as mencoder */
3417 static void opt_pass(const char *pass_str)
3418 {
3419     int pass;
3420     pass = atoi(pass_str);
3421     if (pass != 1 && pass != 2) {
3422         fprintf(stderr, "pass number can be only 1 or 2\n");
3423         av_exit(1);
3424     }
3425     do_pass = pass;
3426 }
3427
3428 static int64_t getutime(void)
3429 {
3430 #ifdef HAVE_GETRUSAGE
3431     struct rusage rusage;
3432
3433     getrusage(RUSAGE_SELF, &rusage);
3434     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3435 #elif defined(HAVE_GETPROCESSTIMES)
3436     HANDLE proc;
3437     FILETIME c, e, k, u;
3438     proc = GetCurrentProcess();
3439     GetProcessTimes(proc, &c, &e, &k, &u);
3440     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3441 #else
3442     return av_gettime();
3443 #endif
3444 }
3445
3446 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3447 {
3448     int i;
3449     const char *p = str;
3450     for(i = 0;; i++) {
3451         dest[i] = atoi(p);
3452         if(i == 63)
3453             break;
3454         p = strchr(p, ',');
3455         if(!p) {
3456             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3457             av_exit(1);
3458         }
3459         p++;
3460     }
3461 }
3462
3463 static void opt_inter_matrix(const char *arg)
3464 {
3465     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3466     parse_matrix_coeffs(inter_matrix, arg);
3467 }
3468
3469 static void opt_intra_matrix(const char *arg)
3470 {
3471     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3472     parse_matrix_coeffs(intra_matrix, arg);
3473 }
3474
3475 /**
3476  * Trivial log callback.
3477  * Only suitable for show_help and similar since it lacks prefix handling.
3478  */
3479 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3480 {
3481     vfprintf(stdout, fmt, vl);
3482 }
3483
3484 static void show_help(void)
3485 {
3486     av_log_set_callback(log_callback_help);
3487     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3488            "Hyper fast Audio and Video encoder\n");
3489     printf("\n");
3490     show_help_options(options, "Main options:\n",
3491                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3492     show_help_options(options, "\nAdvanced options:\n",
3493                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3494                       OPT_EXPERT);
3495     show_help_options(options, "\nVideo options:\n",
3496                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3497                       OPT_VIDEO);
3498     show_help_options(options, "\nAdvanced Video options:\n",
3499                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3500                       OPT_VIDEO | OPT_EXPERT);
3501     show_help_options(options, "\nAudio options:\n",
3502                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3503                       OPT_AUDIO);
3504     show_help_options(options, "\nAdvanced Audio options:\n",
3505                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3506                       OPT_AUDIO | OPT_EXPERT);
3507     show_help_options(options, "\nSubtitle options:\n",
3508                       OPT_SUBTITLE | OPT_GRAB,
3509                       OPT_SUBTITLE);
3510     show_help_options(options, "\nAudio/Video grab options:\n",
3511                       OPT_GRAB,
3512                       OPT_GRAB);
3513     printf("\n");
3514     av_opt_show(avctx_opts[0], NULL);
3515     printf("\n");
3516     av_opt_show(avformat_opts, NULL);
3517     printf("\n");
3518     av_opt_show(sws_opts, NULL);
3519 }
3520
3521 static void opt_target(const char *arg)
3522 {
3523     int norm = -1;
3524     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3525
3526     if(!strncmp(arg, "pal-", 4)) {
3527         norm = 0;
3528         arg += 4;
3529     } else if(!strncmp(arg, "ntsc-", 5)) {
3530         norm = 1;
3531         arg += 5;
3532     } else if(!strncmp(arg, "film-", 5)) {
3533         norm = 2;
3534         arg += 5;
3535     } else {
3536         int fr;
3537         /* Calculate FR via float to avoid int overflow */
3538         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3539         if(fr == 25000) {
3540             norm = 0;
3541         } else if((fr == 29970) || (fr == 23976)) {
3542             norm = 1;
3543         } else {
3544             /* Try to determine PAL/NTSC by peeking in the input files */
3545             if(nb_input_files) {
3546                 int i, j;
3547                 for(j = 0; j < nb_input_files; j++) {
3548                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3549                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3550                         if(c->codec_type != CODEC_TYPE_VIDEO)
3551                             continue;
3552                         fr = c->time_base.den * 1000 / c->time_base.num;
3553                         if(fr == 25000) {
3554                             norm = 0;
3555                             break;
3556                         } else if((fr == 29970) || (fr == 23976)) {
3557                             norm = 1;
3558                             break;
3559                         }
3560                     }
3561                     if(norm >= 0)
3562                         break;
3563                 }
3564             }
3565         }
3566         if(verbose && norm >= 0)
3567             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3568     }
3569
3570     if(norm < 0) {
3571         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3572         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3573         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3574         av_exit(1);
3575     }
3576
3577     if(!strcmp(arg, "vcd")) {
3578
3579         opt_video_codec("mpeg1video");
3580         opt_audio_codec("mp2");
3581         opt_format("vcd");
3582
3583         opt_frame_size(norm ? "352x240" : "352x288");
3584         opt_frame_rate(frame_rates[norm]);
3585         opt_default("gop", norm ? "18" : "15");
3586
3587         opt_default("b", "1150000");
3588         opt_default("maxrate", "1150000");
3589         opt_default("minrate", "1150000");
3590         opt_default("bufsize", "327680"); // 40*1024*8;
3591
3592         opt_default("ab", "224000");
3593         audio_sample_rate = 44100;
3594         audio_channels = 2;
3595
3596         opt_default("packetsize", "2324");
3597         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3598
3599         /* We have to offset the PTS, so that it is consistent with the SCR.
3600            SCR starts at 36000, but the first two packs contain only padding
3601            and the first pack from the other stream, respectively, may also have
3602            been written before.
3603            So the real data starts at SCR 36000+3*1200. */
3604         mux_preload= (36000+3*1200) / 90000.0; //0.44
3605     } else if(!strcmp(arg, "svcd")) {
3606
3607         opt_video_codec("mpeg2video");
3608         opt_audio_codec("mp2");
3609         opt_format("svcd");
3610
3611         opt_frame_size(norm ? "480x480" : "480x576");
3612         opt_frame_rate(frame_rates[norm]);
3613         opt_default("gop", norm ? "18" : "15");
3614
3615         opt_default("b", "2040000");
3616         opt_default("maxrate", "2516000");
3617         opt_default("minrate", "0"); //1145000;
3618         opt_default("bufsize", "1835008"); //224*1024*8;
3619         opt_default("flags", "+SCAN_OFFSET");
3620
3621
3622         opt_default("ab", "224000");
3623         audio_sample_rate = 44100;
3624
3625         opt_default("packetsize", "2324");
3626
3627     } else if(!strcmp(arg, "dvd")) {
3628
3629         opt_video_codec("mpeg2video");
3630         opt_audio_codec("ac3");
3631         opt_format("dvd");
3632
3633         opt_frame_size(norm ? "720x480" : "720x576");
3634         opt_frame_rate(frame_rates[norm]);
3635         opt_default("gop", norm ? "18" : "15");
3636
3637         opt_default("b", "6000000");
3638         opt_default("maxrate", "9000000");
3639         opt_default("minrate", "0"); //1500000;
3640         opt_default("bufsize", "1835008"); //224*1024*8;
3641
3642         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3643         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3644
3645         opt_default("ab", "448000");
3646         audio_sample_rate = 48000;
3647
3648     } else if(!strncmp(arg, "dv", 2)) {
3649
3650         opt_format("dv");
3651
3652         opt_frame_size(norm ? "720x480" : "720x576");
3653         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3654                                              (norm ? "yuv411p" : "yuv420p"));
3655         opt_frame_rate(frame_rates[norm]);
3656
3657         audio_sample_rate = 48000;
3658         audio_channels = 2;
3659
3660     } else {
3661         fprintf(stderr, "Unknown target: %s\n", arg);
3662         av_exit(1);
3663     }
3664 }
3665
3666 static void opt_vstats_file (const char *arg)
3667 {
3668     av_free (vstats_filename);
3669     vstats_filename=av_strdup (arg);
3670 }
3671
3672 static void opt_vstats (void)
3673 {
3674     char filename[40];
3675     time_t today2 = time(NULL);
3676     struct tm *today = localtime(&today2);
3677
3678     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3679              today->tm_sec);
3680     opt_vstats_file(filename);
3681 }
3682
3683 static int opt_bsf(const char *opt, const char *arg)
3684 {
3685     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3686     AVBitStreamFilterContext **bsfp;
3687
3688     if(!bsfc){
3689         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3690         av_exit(1);
3691     }
3692
3693     bsfp= *opt == 'v' ? &video_bitstream_filters :
3694           *opt == 'a' ? &audio_bitstream_filters :
3695                         &subtitle_bitstream_filters;
3696     while(*bsfp)
3697         bsfp= &(*bsfp)->next;
3698
3699     *bsfp= bsfc;
3700
3701     return 0;
3702 }
3703
3704 static int opt_preset(const char *opt, const char *arg)
3705 {
3706     FILE *f=NULL;
3707     char tmp[1000], tmp2[1000];
3708     int i;
3709     const char *base[3]= { getenv("HOME"),
3710                            "/usr/local/share",
3711                            "/usr/share",
3712                          };
3713
3714     for(i=!base[0]; i<3 && !f; i++){
3715         snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3716         f= fopen(tmp, "r");
3717         if(!f){
3718             char *codec_name= *opt == 'v' ? video_codec_name :
3719                               *opt == 'a' ? audio_codec_name :
3720                                             subtitle_codec_name;
3721               snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3722             f= fopen(tmp, "r");
3723         }
3724     }
3725
3726     if(!f){
3727         fprintf(stderr, "Preset file not found\n");
3728         av_exit(1);
3729     }
3730
3731     while(!feof(f)){
3732         int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3733         if(e!=2){
3734             fprintf(stderr, "Preset file invalid\n");
3735             av_exit(1);
3736         }
3737         if(!strcmp(tmp, "acodec")){
3738             opt_audio_codec(tmp2);
3739         }else if(!strcmp(tmp, "vcodec")){
3740             opt_video_codec(tmp2);
3741         }else if(!strcmp(tmp, "scodec")){
3742             opt_subtitle_codec(tmp2);
3743         }else
3744             opt_default(tmp, tmp2);
3745     }
3746
3747     fclose(f);
3748
3749     return 0;
3750 }
3751
3752 static const OptionDef options[] = {
3753     /* main options */
3754     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3755     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3756     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3757     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3758     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3759     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3760     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3761     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3762     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3763     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3764     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3765     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3766     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3767     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3768     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3769     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3770     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3771     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3772     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3773     { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3774     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3775     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3776     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3777       "add timings for benchmarking" },
3778     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3779       "dump each input packet" },
3780     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3781       "when dumping packets, also dump the payload" },
3782     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3783     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3784     { "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)", "" },
3785     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3786     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3787     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3788     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3789     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3790     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3791     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3792     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3793     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3794     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3795     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3796
3797     /* video options */
3798     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3799     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3800     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3801     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3802     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3803     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3804     { "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" },
3805     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3806     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3807     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3808     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3809     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3810     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3811     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3812     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3813     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3814     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3815     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3816     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3817     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3818     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3819     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3820     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3821     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3822       "use same video quality as source (implies VBR)" },
3823     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3824     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3825     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3826       "deinterlace pictures" },
3827     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3828     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3829     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3830 #ifdef CONFIG_VHOOK
3831     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3832 #endif
3833     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3834     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3835     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3836     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3837     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3838     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3839     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3840
3841     /* audio options */
3842     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3843     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3844     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3845     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3846     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3847     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3848     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3849     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3850     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3851     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3852     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3853     { "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" },
3854
3855     /* subtitle options */
3856     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3857     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3858     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3859     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3860
3861     /* grab options */
3862     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3863     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3864     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3865
3866     /* muxer options */
3867     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3868     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3869
3870     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3871     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3872     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3873
3874     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3875     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3876     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3877
3878     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3879     { NULL, },
3880 };
3881
3882 int main(int argc, char **argv)
3883 {
3884     int i;
3885     int64_t ti;
3886
3887     avcodec_register_all();
3888     avdevice_register_all();
3889     av_register_all();
3890
3891     if(isatty(STDIN_FILENO))
3892         url_set_interrupt_cb(decode_interrupt_cb);
3893
3894     for(i=0; i<CODEC_TYPE_NB; i++){
3895         avctx_opts[i]= avcodec_alloc_context2(i);
3896     }
3897     avformat_opts = av_alloc_format_context();
3898     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3899
3900     show_banner();
3901     if (argc <= 1) {
3902         show_help();
3903         av_exit(1);
3904     }
3905
3906     /* parse options */
3907     parse_options(argc, argv, options, opt_output_file);
3908
3909     /* file converter / grab */
3910     if (nb_output_files <= 0) {
3911         fprintf(stderr, "Must supply at least one output file\n");
3912         av_exit(1);
3913     }
3914
3915     if (nb_input_files == 0) {
3916         fprintf(stderr, "Must supply at least one input file\n");
3917         av_exit(1);
3918     }
3919
3920     ti = getutime();
3921     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3922               stream_maps, nb_stream_maps);
3923     ti = getutime() - ti;
3924     if (do_benchmark) {
3925         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3926     }
3927
3928     return av_exit(0);
3929 }