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