git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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