src/recorder/ffmpeg.c

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