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