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