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