src/recorder/ffmpeg.c

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