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