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