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