src/recorder/ffmpeg.c

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