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