ffmpeg.c

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