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