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