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