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