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 thread_count= 1;
 239 static int q_pressed = 0;
 240 static int64_t video_size = 0;
 241 static int64_t audio_size = 0;
 242 static int64_t extra_size = 0;
 243 static int nb_frames_dup = 0;
 244 static int nb_frames_drop = 0;
 245 static int input_sync;
 246 static uint64_t limit_filesize = 0;
 247 static int force_fps = 0;
 248 static char *forced_key_frames = NULL;
 249
 250 static float dts_delta_threshold = 10;
 251
 252 static int64_t timer_start;
 253
 254 static uint8_t *audio_buf;
 255 static uint8_t *audio_out;
 256 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
 257
 258 static short *samples;
 259
 260 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 261 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 262 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 263
 264 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
 265
 266 struct AVInputStream;
 267
 268 typedef struct AVOutputStream {
 269     int file_index;          /* file index */
 270     int index;               /* stream index in the output file */
 271     int source_index;        /* AVInputStream index */
 272     AVStream *st;            /* stream in the output file */
 273     int encoding_needed;     /* true if encoding needed for this stream */
 274     int frame_number;
 275     /* input pts and corresponding output pts
 276        for A/V sync */
 277     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 278     struct AVInputStream *sync_ist; /* input stream to sync against */
 279     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 280     AVBitStreamFilterContext *bitstream_filters;
 281     /* video only */
 282     int video_resample;
 283     AVFrame pict_tmp;      /* temporary image for resampling */
 284     struct SwsContext *img_resample_ctx; /* for image resampling */
 285     int resample_height;
 286     int resample_width;
 287     int resample_pix_fmt;
 288
 289     float frame_aspect_ratio;
 290
 291     /* full frame size of first frame */
 292     int original_height;
 293     int original_width;
 294
 295     /* forced key frames */
 296     int64_t *forced_kf_pts;
 297     int forced_kf_count;
 298     int forced_kf_index;
 299
 300     /* audio only */
 301     int audio_resample;
 302     ReSampleContext *resample; /* for audio resampling */
 303     int resample_sample_fmt;
 304     int resample_channels;
 305     int resample_sample_rate;
 306     int reformat_pair;
 307     AVAudioConvert *reformat_ctx;
 308     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 309     FILE *logfile;
 310
 311 #if CONFIG_AVFILTER
 312     AVFilterContext *output_video_filter;
 313     AVFilterContext *input_video_filter;
 314     AVFilterBufferRef *picref;
 315     char *avfilter;
 316     AVFilterGraph *graph;
 317 #endif
 318 } AVOutputStream;
 319
 320 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
 321 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
 322
 323 typedef struct AVInputStream {
 324     int file_index;
 325     int index;
 326     AVStream *st;
 327     int discard;             /* true if stream data should be discarded */
 328     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 329     int64_t sample_index;      /* current sample */
 330
 331     int64_t       start;     /* time when read started */
 332     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 333                                 is not defined */
 334     int64_t       pts;       /* current pts */
 335     int is_start;            /* is 1 at the start and after a discontinuity */
 336     int showed_multi_packet_warning;
 337     int is_past_recording_time;
 338 #if CONFIG_AVFILTER
 339     AVFrame *filter_frame;
 340     int has_filter_frame;
 341 #endif
 342 } AVInputStream;
 343
 344 typedef struct AVInputFile {
 345     int eof_reached;      /* true if eof reached */
 346     int ist_index;        /* index of first stream in ist_table */
 347     int buffer_size;      /* current total buffer size */
 348     int nb_streams;       /* nb streams we are aware of */
 349 } AVInputFile;
 350
 351 #if HAVE_TERMIOS_H
 352
 353 /* init terminal so that we can grab keys */
 354 static struct termios oldtty;
 355 #endif
 356
 357 #if CONFIG_AVFILTER
 358
 359 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
 360 {
 361     AVFilterContext *last_filter, *filter;
 362     /** filter graph containing all filters including input & output */
 363     AVCodecContext *codec = ost->st->codec;
 364     AVCodecContext *icodec = ist->st->codec;
 365     FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
 366     AVRational sample_aspect_ratio;
 367     char args[255];
 368     int ret;
 369
 370     ost->graph = avfilter_graph_alloc();
 371
 372     if (ist->st->sample_aspect_ratio.num){
 373         sample_aspect_ratio = ist->st->sample_aspect_ratio;
 374     }else
 375         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
 376
 377     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
 378              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 379              sample_aspect_ratio.num, sample_aspect_ratio.den);
 380
 381     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
 382                                        "src", args, NULL, ost->graph);
 383     if (ret < 0)
 384         return ret;
 385     ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
 386                                        "out", NULL, &ffsink_ctx, ost->graph);
 387     if (ret < 0)
 388         return ret;
 389     last_filter = ost->input_video_filter;
 390
 391     if (codec->width  != icodec->width || codec->height != icodec->height) {
 392         snprintf(args, 255, "%d:%d:flags=0x%X",
 393                  codec->width,
 394                  codec->height,
 395                  (int)av_get_int(sws_opts, "sws_flags", NULL));
 396         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 397                                                 NULL, args, NULL, ost->graph)) < 0)
 398             return ret;
 399         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
 400             return ret;
 401         last_filter = filter;
 402     }
 403
 404     snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
 405     ost->graph->scale_sws_opts = av_strdup(args);
 406
 407     if (ost->avfilter) {
 408         AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
 409         AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
 410
 411         outputs->name    = av_strdup("in");
 412         outputs->filter_ctx = last_filter;
 413         outputs->pad_idx = 0;
 414         outputs->next    = NULL;
 415
 416         inputs->name    = av_strdup("out");
 417         inputs->filter_ctx = ost->output_video_filter;
 418         inputs->pad_idx = 0;
 419         inputs->next    = NULL;
 420
 421         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
 422             return ret;
 423         av_freep(&ost->avfilter);
 424     } else {
 425         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
 426             return ret;
 427     }
 428
 429     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
 430         return ret;
 431
 432     codec->width  = ost->output_video_filter->inputs[0]->w;
 433     codec->height = ost->output_video_filter->inputs[0]->h;
 434     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
 435         ost->frame_aspect_ratio ? // overriden by the -aspect cli option
 436         av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
 437         ost->output_video_filter->inputs[0]->sample_aspect_ratio;
 438
 439     return 0;
 440 }
 441 #endif /* CONFIG_AVFILTER */
 442
 443 static void term_exit(void)
 444 {
 445     av_log(NULL, AV_LOG_QUIET, "");
 446 #if HAVE_TERMIOS_H
 447     tcsetattr (0, TCSANOW, &oldtty);
 448 #endif
 449 }
 450
 451 static volatile int received_sigterm = 0;
 452
 453 static void
 454 sigterm_handler(int sig)
 455 {
 456     received_sigterm = sig;
 457     q_pressed++;
 458     term_exit();
 459 }
 460
 461 static void term_init(void)
 462 {
 463 #if HAVE_TERMIOS_H
 464     struct termios tty;
 465
 466     tcgetattr (0, &tty);
 467     oldtty = tty;
 468     atexit(term_exit);
 469
 470     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 471                           |INLCR|IGNCR|ICRNL|IXON);
 472     tty.c_oflag |= OPOST;
 473     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 474     tty.c_cflag &= ~(CSIZE|PARENB);
 475     tty.c_cflag |= CS8;
 476     tty.c_cc[VMIN] = 1;
 477     tty.c_cc[VTIME] = 0;
 478
 479     tcsetattr (0, TCSANOW, &tty);
 480     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 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     FD_ZERO(&rfds);
 500     FD_SET(0, &rfds);
 501     tv.tv_sec = 0;
 502     tv.tv_usec = 0;
 503     n = select(1, &rfds, NULL, NULL, &tv);
 504     if (n > 0) {
 505         n = read(0, &ch, 1);
 506         if (n == 1)
 507             return ch;
 508
 509         return n;
 510     }
 511 #elif HAVE_KBHIT
 512     if(kbhit())
 513         return(getch());
 514 #endif
 515     return -1;
 516 }
 517
 518 static int decode_interrupt_cb(void)
 519 {
 520     q_pressed += read_key() == 'q';
 521     return q_pressed > 1;
 522 }
 523
 524 static int ffmpeg_exit(int ret)
 525 {
 526     int i;
 527
 528     /* close files */
 529     for(i=0;i<nb_output_files;i++) {
 530         AVFormatContext *s = output_files[i];
 531         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 532             avio_close(s->pb);
 533         avformat_free_context(s);
 534         av_free(output_streams_for_file[i]);
 535     }
 536     for(i=0;i<nb_input_files;i++) {
 537         av_close_input_file(input_files[i]);
 538         av_free(input_files_ts_scale[i]);
 539     }
 540
 541     av_free(intra_matrix);
 542     av_free(inter_matrix);
 543
 544     if (vstats_file)
 545         fclose(vstats_file);
 546     av_free(vstats_filename);
 547
 548     av_free(streamid_map);
 549     av_free(input_codecs);
 550     av_free(output_codecs);
 551     av_free(stream_maps);
 552     av_free(meta_data_maps);
 553
 554     av_free(video_codec_name);
 555     av_free(audio_codec_name);
 556     av_free(subtitle_codec_name);
 557
 558     av_free(video_standard);
 559
 560     uninit_opts();
 561     av_free(audio_buf);
 562     av_free(audio_out);
 563     allocated_audio_buf_size= allocated_audio_out_size= 0;
 564     av_free(samples);
 565
 566 #if CONFIG_AVFILTER
 567     avfilter_uninit();
 568 #endif
 569
 570     if (received_sigterm) {
 571         fprintf(stderr,
 572             "Received signal %d: terminating.\n",
 573             (int) received_sigterm);
 574         exit (255);
 575     }
 576
 577     exit(ret); /* not all OS-es handle main() return value */
 578     return ret;
 579 }
 580
 581 /* similar to ff_dynarray_add() and av_fast_realloc() */
 582 static void *grow_array(void *array, int elem_size, int *size, int new_size)
 583 {
 584     if (new_size >= INT_MAX / elem_size) {
 585         fprintf(stderr, "Array too big.\n");
 586         ffmpeg_exit(1);
 587     }
 588     if (*size < new_size) {
 589         uint8_t *tmp = av_realloc(array, new_size*elem_size);
 590         if (!tmp) {
 591             fprintf(stderr, "Could not alloc buffer.\n");
 592             ffmpeg_exit(1);
 593         }
 594         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
 595         *size = new_size;
 596         return tmp;
 597     }
 598     return array;
 599 }
 600
 601 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
 602 {
 603     if(codec && codec->sample_fmts){
 604         const enum AVSampleFormat *p= codec->sample_fmts;
 605         for(; *p!=-1; p++){
 606             if(*p == st->codec->sample_fmt)
 607                 break;
 608         }
 609         if (*p == -1) {
 610             av_log(NULL, AV_LOG_WARNING,
 611                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
 612                    av_get_sample_fmt_name(st->codec->sample_fmt),
 613                    codec->name,
 614                    av_get_sample_fmt_name(codec->sample_fmts[0]));
 615             st->codec->sample_fmt = codec->sample_fmts[0];
 616         }
 617     }
 618 }
 619
 620 static void choose_sample_rate(AVStream *st, AVCodec *codec)
 621 {
 622     if(codec && codec->supported_samplerates){
 623         const int *p= codec->supported_samplerates;
 624         int best=0;
 625         int best_dist=INT_MAX;
 626         for(; *p; p++){
 627             int dist= abs(st->codec->sample_rate - *p);
 628             if(dist < best_dist){
 629                 best_dist= dist;
 630                 best= *p;
 631             }
 632         }
 633         if(best_dist){
 634             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
 635         }
 636         st->codec->sample_rate= best;
 637     }
 638 }
 639
 640 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
 641 {
 642     if(codec && codec->pix_fmts){
 643         const enum PixelFormat *p= codec->pix_fmts;
 644         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
 645             if(st->codec->codec_id==CODEC_ID_MJPEG){
 646                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
 647             }else if(st->codec->codec_id==CODEC_ID_LJPEG){
 648                 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};
 649             }
 650         }
 651         for(; *p!=-1; p++){
 652             if(*p == st->codec->pix_fmt)
 653                 break;
 654         }
 655         if (*p == -1) {
 656             if(st->codec->pix_fmt != PIX_FMT_NONE)
 657             av_log(NULL, AV_LOG_WARNING,
 658                    "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 659                    av_pix_fmt_descriptors[st->codec->pix_fmt].name,
 660                    codec->name,
 661                    av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
 662             st->codec->pix_fmt = codec->pix_fmts[0];
 663         }
 664     }
 665 }
 666
 667 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
 668 {
 669     int idx = oc->nb_streams - 1;
 670     AVOutputStream *ost;
 671
 672     output_streams_for_file[file_idx] =
 673         grow_array(output_streams_for_file[file_idx],
 674                    sizeof(*output_streams_for_file[file_idx]),
 675                    &nb_output_streams_for_file[file_idx],
 676                    oc->nb_streams);
 677     ost = output_streams_for_file[file_idx][idx] =
 678         av_mallocz(sizeof(AVOutputStream));
 679     if (!ost) {
 680         fprintf(stderr, "Could not alloc output stream\n");
 681         ffmpeg_exit(1);
 682     }
 683     ost->file_index = file_idx;
 684     ost->index = idx;
 685     return ost;
 686 }
 687
 688 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
 689 {
 690     int i, err;
 691     AVFormatContext *ic;
 692     int nopts = 0;
 693
 694     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
 695     if (err < 0)
 696         return err;
 697     /* copy stream format */
 698     s->nb_streams = 0;
 699     for(i=0;i<ic->nb_streams;i++) {
 700         AVStream *st;
 701         AVCodec *codec;
 702
 703         s->nb_streams++;
 704
 705         // FIXME: a more elegant solution is needed
 706         st = av_mallocz(sizeof(AVStream));
 707         memcpy(st, ic->streams[i], sizeof(AVStream));
 708         st->codec = avcodec_alloc_context();
 709         if (!st->codec) {
 710             print_error(filename, AVERROR(ENOMEM));
 711             ffmpeg_exit(1);
 712         }
 713         avcodec_copy_context(st->codec, ic->streams[i]->codec);
 714         s->streams[i] = st;
 715
 716         codec = avcodec_find_encoder(st->codec->codec_id);
 717         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 718             if (audio_stream_copy) {
 719                 st->stream_copy = 1;
 720             } else
 721                 choose_sample_fmt(st, codec);
 722         } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 723             if (video_stream_copy) {
 724                 st->stream_copy = 1;
 725             } else
 726                 choose_pixel_fmt(st, codec);
 727         }
 728
 729         if(st->codec->flags & CODEC_FLAG_BITEXACT)
 730             nopts = 1;
 731
 732         new_output_stream(s, nb_output_files);
 733     }
 734
 735     if (!nopts)
 736         s->timestamp = av_gettime();
 737
 738     av_close_input_file(ic);
 739     return 0;
 740 }
 741
 742 static double
 743 get_sync_ipts(const AVOutputStream *ost)
 744 {
 745     const AVInputStream *ist = ost->sync_ist;
 746     return (double)(ist->pts - start_time)/AV_TIME_BASE;
 747 }
 748
 749 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 750     int ret;
 751
 752     while(bsfc){
 753         AVPacket new_pkt= *pkt;
 754         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 755                                           &new_pkt.data, &new_pkt.size,
 756                                           pkt->data, pkt->size,
 757                                           pkt->flags & AV_PKT_FLAG_KEY);
 758         if(a>0){
 759             av_free_packet(pkt);
 760             new_pkt.destruct= av_destruct_packet;
 761         } else if(a<0){
 762             fprintf(stderr, "%s failed for stream %d, codec %s",
 763                     bsfc->filter->name, pkt->stream_index,
 764                     avctx->codec ? avctx->codec->name : "copy");
 765             print_error("", a);
 766             if (exit_on_error)
 767                 ffmpeg_exit(1);
 768         }
 769         *pkt= new_pkt;
 770
 771         bsfc= bsfc->next;
 772     }
 773
 774     ret= av_interleaved_write_frame(s, pkt);
 775     if(ret < 0){
 776         print_error("av_interleaved_write_frame()", ret);
 777         ffmpeg_exit(1);
 778     }
 779 }
 780
 781 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 782
 783 static void do_audio_out(AVFormatContext *s,
 784                          AVOutputStream *ost,
 785                          AVInputStream *ist,
 786                          unsigned char *buf, int size)
 787 {
 788     uint8_t *buftmp;
 789     int64_t audio_out_size, audio_buf_size;
 790     int64_t allocated_for_size= size;
 791
 792     int size_out, frame_bytes, ret, resample_changed;
 793     AVCodecContext *enc= ost->st->codec;
 794     AVCodecContext *dec= ist->st->codec;
 795     int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
 796     int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
 797     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
 798
 799 need_realloc:
 800     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
 801     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
 802     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
 803     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
 804     audio_buf_size*= osize*enc->channels;
 805
 806     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
 807     if(coded_bps > 8*osize)
 808         audio_out_size= audio_out_size * coded_bps / (8*osize);
 809     audio_out_size += FF_MIN_BUFFER_SIZE;
 810
 811     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
 812         fprintf(stderr, "Buffer sizes too large\n");
 813         ffmpeg_exit(1);
 814     }
 815
 816     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
 817     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
 818     if (!audio_buf || !audio_out){
 819         fprintf(stderr, "Out of memory in do_audio_out\n");
 820         ffmpeg_exit(1);
 821     }
 822
 823     if (enc->channels != dec->channels)
 824         ost->audio_resample = 1;
 825
 826     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
 827                        ost->resample_channels    != dec->channels   ||
 828                        ost->resample_sample_rate != dec->sample_rate;
 829
 830     if ((ost->audio_resample && !ost->resample) || resample_changed) {
 831         if (resample_changed) {
 832             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",
 833                    ist->file_index, ist->index,
 834                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
 835                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
 836             ost->resample_sample_fmt  = dec->sample_fmt;
 837             ost->resample_channels    = dec->channels;
 838             ost->resample_sample_rate = dec->sample_rate;
 839             if (ost->resample)
 840                 audio_resample_close(ost->resample);
 841         }
 842         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
 843         if (audio_sync_method <= 1 &&
 844             ost->resample_sample_fmt  == enc->sample_fmt &&
 845             ost->resample_channels    == enc->channels   &&
 846             ost->resample_sample_rate == enc->sample_rate) {
 847             ost->resample = NULL;
 848             ost->audio_resample = 0;
 849         } else {
 850             if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
 851                 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
 852             ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
 853                                                    enc->sample_rate, dec->sample_rate,
 854                                                    enc->sample_fmt,  dec->sample_fmt,
 855                                                    16, 10, 0, 0.8);
 856             if (!ost->resample) {
 857                 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 858                         dec->channels, dec->sample_rate,
 859                         enc->channels, enc->sample_rate);
 860                 ffmpeg_exit(1);
 861             }
 862         }
 863     }
 864
 865 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
 866     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
 867         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
 868         if (ost->reformat_ctx)
 869             av_audio_convert_free(ost->reformat_ctx);
 870         ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
 871                                                    dec->sample_fmt, 1, NULL, 0);
 872         if (!ost->reformat_ctx) {
 873             fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
 874                 av_get_sample_fmt_name(dec->sample_fmt),
 875                 av_get_sample_fmt_name(enc->sample_fmt));
 876             ffmpeg_exit(1);
 877         }
 878         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
 879     }
 880
 881     if(audio_sync_method){
 882         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 883                 - av_fifo_size(ost->fifo)/(enc->channels * 2);
 884         double idelta= delta*dec->sample_rate / enc->sample_rate;
 885         int byte_delta= ((int)idelta)*2*dec->channels;
 886
 887         //FIXME resample delay
 888         if(fabs(delta) > 50){
 889             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 890                 if(byte_delta < 0){
 891                     byte_delta= FFMAX(byte_delta, -size);
 892                     size += byte_delta;
 893                     buf  -= byte_delta;
 894                     if(verbose > 2)
 895                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 896                     if(!size)
 897                         return;
 898                     ist->is_start=0;
 899                 }else{
 900                     static uint8_t *input_tmp= NULL;
 901                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 902
 903                     if(byte_delta > allocated_for_size - size){
 904                         allocated_for_size= byte_delta + (int64_t)size;
 905                         goto need_realloc;
 906                     }
 907                     ist->is_start=0;
 908
 909                     memset(input_tmp, 0, byte_delta);
 910                     memcpy(input_tmp + byte_delta, buf, size);
 911                     buf= input_tmp;
 912                     size += byte_delta;
 913                     if(verbose > 2)
 914                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 915                 }
 916             }else if(audio_sync_method>1){
 917                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 918                 av_assert0(ost->audio_resample);
 919                 if(verbose > 2)
 920                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 921 //                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));
 922                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 923             }
 924         }
 925     }else
 926         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 927                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
 928
 929     if (ost->audio_resample) {
 930         buftmp = audio_buf;
 931         size_out = audio_resample(ost->resample,
 932                                   (short *)buftmp, (short *)buf,
 933                                   size / (dec->channels * isize));
 934         size_out = size_out * enc->channels * osize;
 935     } else {
 936         buftmp = buf;
 937         size_out = size;
 938     }
 939
 940     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
 941         const void *ibuf[6]= {buftmp};
 942         void *obuf[6]= {audio_buf};
 943         int istride[6]= {isize};
 944         int ostride[6]= {osize};
 945         int len= size_out/istride[0];
 946         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
 947             printf("av_audio_convert() failed\n");
 948             if (exit_on_error)
 949                 ffmpeg_exit(1);
 950             return;
 951         }
 952         buftmp = audio_buf;
 953         size_out = len*osize;
 954     }
 955
 956     /* now encode as many frames as possible */
 957     if (enc->frame_size > 1) {
 958         /* output resampled raw samples */
 959         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
 960             fprintf(stderr, "av_fifo_realloc2() failed\n");
 961             ffmpeg_exit(1);
 962         }
 963         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
 964
 965         frame_bytes = enc->frame_size * osize * enc->channels;
 966
 967         while (av_fifo_size(ost->fifo) >= frame_bytes) {
 968             AVPacket pkt;
 969             av_init_packet(&pkt);
 970
 971             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
 972
 973             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 974
 975             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 976                                        (short *)audio_buf);
 977             if (ret < 0) {
 978                 fprintf(stderr, "Audio encoding failed\n");
 979                 ffmpeg_exit(1);
 980             }
 981             audio_size += ret;
 982             pkt.stream_index= ost->index;
 983             pkt.data= audio_out;
 984             pkt.size= ret;
 985             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 986                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 987             pkt.flags |= AV_PKT_FLAG_KEY;
 988             write_frame(s, &pkt, enc, ost->bitstream_filters);
 989
 990             ost->sync_opts += enc->frame_size;
 991         }
 992     } else {
 993         AVPacket pkt;
 994         av_init_packet(&pkt);
 995
 996         ost->sync_opts += size_out / (osize * enc->channels);
 997
 998         /* output a pcm frame */
 999         /* determine the size of the coded buffer */
1000         size_out /= osize;
1001         if (coded_bps)
1002             size_out = size_out*coded_bps/8;
1003
1004         if(size_out > audio_out_size){
1005             fprintf(stderr, "Internal error, buffer size too small\n");
1006             ffmpeg_exit(1);
1007         }
1008
1009         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1010         ret = avcodec_encode_audio(enc, audio_out, size_out,
1011                                    (short *)buftmp);
1012         if (ret < 0) {
1013             fprintf(stderr, "Audio encoding failed\n");
1014             ffmpeg_exit(1);
1015         }
1016         audio_size += ret;
1017         pkt.stream_index= ost->index;
1018         pkt.data= audio_out;
1019         pkt.size= ret;
1020         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1021             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1022         pkt.flags |= AV_PKT_FLAG_KEY;
1023         write_frame(s, &pkt, enc, ost->bitstream_filters);
1024     }
1025 }
1026
1027 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1028 {
1029     AVCodecContext *dec;
1030     AVPicture *picture2;
1031     AVPicture picture_tmp;
1032     uint8_t *buf = 0;
1033
1034     dec = ist->st->codec;
1035
1036     /* deinterlace : must be done before any resize */
1037     if (do_deinterlace) {
1038         int size;
1039
1040         /* create temporary picture */
1041         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1042         buf = av_malloc(size);
1043         if (!buf)
1044             return;
1045
1046         picture2 = &picture_tmp;
1047         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1048
1049         if(avpicture_deinterlace(picture2, picture,
1050                                  dec->pix_fmt, dec->width, dec->height) < 0) {
1051             /* if error, do not deinterlace */
1052             fprintf(stderr, "Deinterlacing failed\n");
1053             av_free(buf);
1054             buf = NULL;
1055             picture2 = picture;
1056         }
1057     } else {
1058         picture2 = picture;
1059     }
1060
1061     if (picture != picture2)
1062         *picture = *picture2;
1063     *bufp = buf;
1064 }
1065
1066 /* we begin to correct av delay at this threshold */
1067 #define AV_DELAY_MAX 0.100
1068
1069 static void do_subtitle_out(AVFormatContext *s,
1070                             AVOutputStream *ost,
1071                             AVInputStream *ist,
1072                             AVSubtitle *sub,
1073                             int64_t pts)
1074 {
1075     static uint8_t *subtitle_out = NULL;
1076     int subtitle_out_max_size = 1024 * 1024;
1077     int subtitle_out_size, nb, i;
1078     AVCodecContext *enc;
1079     AVPacket pkt;
1080
1081     if (pts == AV_NOPTS_VALUE) {
1082         fprintf(stderr, "Subtitle packets must have a pts\n");
1083         if (exit_on_error)
1084             ffmpeg_exit(1);
1085         return;
1086     }
1087
1088     enc = ost->st->codec;
1089
1090     if (!subtitle_out) {
1091         subtitle_out = av_malloc(subtitle_out_max_size);
1092     }
1093
1094     /* Note: DVB subtitle need one packet to draw them and one other
1095        packet to clear them */
1096     /* XXX: signal it in the codec context ? */
1097     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1098         nb = 2;
1099     else
1100         nb = 1;
1101
1102     for(i = 0; i < nb; i++) {
1103         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1104         // start_display_time is required to be 0
1105         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1106         sub->end_display_time -= sub->start_display_time;
1107         sub->start_display_time = 0;
1108         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1109                                                     subtitle_out_max_size, sub);
1110         if (subtitle_out_size < 0) {
1111             fprintf(stderr, "Subtitle encoding failed\n");
1112             ffmpeg_exit(1);
1113         }
1114
1115         av_init_packet(&pkt);
1116         pkt.stream_index = ost->index;
1117         pkt.data = subtitle_out;
1118         pkt.size = subtitle_out_size;
1119         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1120         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1121             /* XXX: the pts correction is handled here. Maybe handling
1122                it in the codec would be better */
1123             if (i == 0)
1124                 pkt.pts += 90 * sub->start_display_time;
1125             else
1126                 pkt.pts += 90 * sub->end_display_time;
1127         }
1128         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1129     }
1130 }
1131
1132 static int bit_buffer_size= 1024*256;
1133 static uint8_t *bit_buffer= NULL;
1134
1135 static void do_video_out(AVFormatContext *s,
1136                          AVOutputStream *ost,
1137                          AVInputStream *ist,
1138                          AVFrame *in_picture,
1139                          int *frame_size)
1140 {
1141     int nb_frames, i, ret;
1142     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1143     AVCodecContext *enc, *dec;
1144     double sync_ipts;
1145
1146     enc = ost->st->codec;
1147     dec = ist->st->codec;
1148
1149     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1150
1151     /* by default, we output a single frame */
1152     nb_frames = 1;
1153
1154     *frame_size = 0;
1155
1156     if(video_sync_method){
1157         double vdelta = sync_ipts - ost->sync_opts;
1158         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1159         if (vdelta < -1.1)
1160             nb_frames = 0;
1161         else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1162             if(vdelta<=-0.6){
1163                 nb_frames=0;
1164             }else if(vdelta>0.6)
1165                 ost->sync_opts= lrintf(sync_ipts);
1166         }else if (vdelta > 1.1)
1167             nb_frames = lrintf(vdelta);
1168 //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);
1169         if (nb_frames == 0){
1170             ++nb_frames_drop;
1171             if (verbose>2)
1172                 fprintf(stderr, "*** drop!\n");
1173         }else if (nb_frames > 1) {
1174             nb_frames_dup += nb_frames - 1;
1175             if (verbose>2)
1176                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1177         }
1178     }else
1179         ost->sync_opts= lrintf(sync_ipts);
1180
1181     nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1182     if (nb_frames <= 0)
1183         return;
1184
1185     formatted_picture = in_picture;
1186     final_picture = formatted_picture;
1187     padding_src = formatted_picture;
1188     resampling_dst = &ost->pict_tmp;
1189
1190     if (   ost->resample_height != ist->st->codec->height
1191         || ost->resample_width  != ist->st->codec->width
1192         || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1193
1194         fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1195         if(!ost->video_resample)
1196             ffmpeg_exit(1);
1197     }
1198
1199 #if !CONFIG_AVFILTER
1200     if (ost->video_resample) {
1201         padding_src = NULL;
1202         final_picture = &ost->pict_tmp;
1203         if(  ost->resample_height != ist->st->codec->height
1204           || ost->resample_width  != ist->st->codec->width
1205           || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1206
1207             /* initialize a new scaler context */
1208             sws_freeContext(ost->img_resample_ctx);
1209             sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1210             ost->img_resample_ctx = sws_getContext(
1211                 ist->st->codec->width,
1212                 ist->st->codec->height,
1213                 ist->st->codec->pix_fmt,
1214                 ost->st->codec->width,
1215                 ost->st->codec->height,
1216                 ost->st->codec->pix_fmt,
1217                 sws_flags, NULL, NULL, NULL);
1218             if (ost->img_resample_ctx == NULL) {
1219                 fprintf(stderr, "Cannot get resampling context\n");
1220                 ffmpeg_exit(1);
1221             }
1222         }
1223         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1224               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1225     }
1226 #endif
1227
1228     /* duplicates frame if needed */
1229     for(i=0;i<nb_frames;i++) {
1230         AVPacket pkt;
1231         av_init_packet(&pkt);
1232         pkt.stream_index= ost->index;
1233
1234         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1235             /* raw pictures are written as AVPicture structure to
1236                avoid any copies. We support temorarily the older
1237                method. */
1238             AVFrame* old_frame = enc->coded_frame;
1239             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1240             pkt.data= (uint8_t *)final_picture;
1241             pkt.size=  sizeof(AVPicture);
1242             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1243             pkt.flags |= AV_PKT_FLAG_KEY;
1244
1245             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1246             enc->coded_frame = old_frame;
1247         } else {
1248             AVFrame big_picture;
1249
1250             big_picture= *final_picture;
1251             /* better than nothing: use input picture interlaced
1252                settings */
1253             big_picture.interlaced_frame = in_picture->interlaced_frame;
1254             if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1255                 if(top_field_first == -1)
1256                     big_picture.top_field_first = in_picture->top_field_first;
1257                 else
1258                     big_picture.top_field_first = top_field_first;
1259             }
1260
1261             /* handles sameq here. This is not correct because it may
1262                not be a global option */
1263             big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1264             if(!me_threshold)
1265                 big_picture.pict_type = 0;
1266 //            big_picture.pts = AV_NOPTS_VALUE;
1267             big_picture.pts= ost->sync_opts;
1268 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1269 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1270             if (ost->forced_kf_index < ost->forced_kf_count &&
1271                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1272                 big_picture.pict_type = FF_I_TYPE;
1273                 ost->forced_kf_index++;
1274             }
1275             ret = avcodec_encode_video(enc,
1276                                        bit_buffer, bit_buffer_size,
1277                                        &big_picture);
1278             if (ret < 0) {
1279                 fprintf(stderr, "Video encoding failed\n");
1280                 ffmpeg_exit(1);
1281             }
1282
1283             if(ret>0){
1284                 pkt.data= bit_buffer;
1285                 pkt.size= ret;
1286                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1287                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1288 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1289    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1290    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1291
1292                 if(enc->coded_frame->key_frame)
1293                     pkt.flags |= AV_PKT_FLAG_KEY;
1294                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1295                 *frame_size = ret;
1296                 video_size += ret;
1297                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1298                 //        enc->frame_number-1, ret, enc->pict_type);
1299                 /* if two pass, output log */
1300                 if (ost->logfile && enc->stats_out) {
1301                     fprintf(ost->logfile, "%s", enc->stats_out);
1302                 }
1303             }
1304         }
1305         ost->sync_opts++;
1306         ost->frame_number++;
1307     }
1308 }
1309
1310 static double psnr(double d){
1311     return -10.0*log(d)/log(10.0);
1312 }
1313
1314 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1315                            int frame_size)
1316 {
1317     AVCodecContext *enc;
1318     int frame_number;
1319     double ti1, bitrate, avg_bitrate;
1320
1321     /* this is executed just the first time do_video_stats is called */
1322     if (!vstats_file) {
1323         vstats_file = fopen(vstats_filename, "w");
1324         if (!vstats_file) {
1325             perror("fopen");
1326             ffmpeg_exit(1);
1327         }
1328     }
1329
1330     enc = ost->st->codec;
1331     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1332         frame_number = ost->frame_number;
1333         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1334         if (enc->flags&CODEC_FLAG_PSNR)
1335             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1336
1337         fprintf(vstats_file,"f_size= %6d ", frame_size);
1338         /* compute pts value */
1339         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1340         if (ti1 < 0.01)
1341             ti1 = 0.01;
1342
1343         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1344         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1345         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1346             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1347         fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1348     }
1349 }
1350
1351 static void print_report(AVFormatContext **output_files,
1352                          AVOutputStream **ost_table, int nb_ostreams,
1353                          int is_last_report)
1354 {
1355     char buf[1024];
1356     AVOutputStream *ost;
1357     AVFormatContext *oc;
1358     int64_t total_size;
1359     AVCodecContext *enc;
1360     int frame_number, vid, i;
1361     double bitrate, ti1, pts;
1362     static int64_t last_time = -1;
1363     static int qp_histogram[52];
1364
1365     if (!is_last_report) {
1366         int64_t cur_time;
1367         /* display the report every 0.5 seconds */
1368         cur_time = av_gettime();
1369         if (last_time == -1) {
1370             last_time = cur_time;
1371             return;
1372         }
1373         if ((cur_time - last_time) < 500000)
1374             return;
1375         last_time = cur_time;
1376     }
1377
1378
1379     oc = output_files[0];
1380
1381     total_size = avio_size(oc->pb);
1382     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1383         total_size= avio_tell(oc->pb);
1384
1385     buf[0] = '\0';
1386     ti1 = 1e10;
1387     vid = 0;
1388     for(i=0;i<nb_ostreams;i++) {
1389         float q= -1;
1390         ost = ost_table[i];
1391         enc = ost->st->codec;
1392         if(!ost->st->stream_copy && enc->coded_frame)
1393             q= enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1394         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1395             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1396         }
1397         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1398             float t = (av_gettime()-timer_start) / 1000000.0;
1399
1400             frame_number = ost->frame_number;
1401             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1402                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1403             if(is_last_report)
1404                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1405             if(qp_hist){
1406                 int j;
1407                 int qp= lrintf(q);
1408                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1409                     qp_histogram[qp]++;
1410                 for(j=0; j<32; j++)
1411                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1412             }
1413             if (enc->flags&CODEC_FLAG_PSNR){
1414                 int j;
1415                 double error, error_sum=0;
1416                 double scale, scale_sum=0;
1417                 char type[3]= {'Y','U','V'};
1418                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1419                 for(j=0; j<3; j++){
1420                     if(is_last_report){
1421                         error= enc->error[j];
1422                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1423                     }else{
1424                         error= enc->coded_frame->error[j];
1425                         scale= enc->width*enc->height*255.0*255.0;
1426                     }
1427                     if(j) scale/=4;
1428                     error_sum += error;
1429                     scale_sum += scale;
1430                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1431                 }
1432                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1433             }
1434             vid = 1;
1435         }
1436         /* compute min output value */
1437         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1438         if ((pts < ti1) && (pts > 0))
1439             ti1 = pts;
1440     }
1441     if (ti1 < 0.01)
1442         ti1 = 0.01;
1443
1444     if (verbose > 0 || is_last_report) {
1445         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1446
1447         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1448             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1449             (double)total_size / 1024, ti1, bitrate);
1450
1451         if (nb_frames_dup || nb_frames_drop)
1452           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1453                   nb_frames_dup, nb_frames_drop);
1454
1455         if (verbose >= 0)
1456             fprintf(stderr, "%s    \r", buf);
1457
1458         fflush(stderr);
1459     }
1460
1461     if (is_last_report && verbose >= 0){
1462         int64_t raw= audio_size + video_size + extra_size;
1463         fprintf(stderr, "\n");
1464         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1465                 video_size/1024.0,
1466                 audio_size/1024.0,
1467                 extra_size/1024.0,
1468                 100.0*(total_size - raw)/raw
1469         );
1470     }
1471 }
1472
1473 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1474 {
1475     int fill_char = 0x00;
1476     if (sample_fmt == AV_SAMPLE_FMT_U8)
1477         fill_char = 0x80;
1478     memset(buf, fill_char, size);
1479 }
1480
1481 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1482 static int output_packet(AVInputStream *ist, int ist_index,
1483                          AVOutputStream **ost_table, int nb_ostreams,
1484                          const AVPacket *pkt)
1485 {
1486     AVFormatContext *os;
1487     AVOutputStream *ost;
1488     int ret, i;
1489     int got_picture;
1490     AVFrame picture;
1491     void *buffer_to_free;
1492     static unsigned int samples_size= 0;
1493     AVSubtitle subtitle, *subtitle_to_free;
1494     int64_t pkt_pts = AV_NOPTS_VALUE;
1495 #if CONFIG_AVFILTER
1496     int frame_available;
1497 #endif
1498
1499     AVPacket avpkt;
1500     int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1501
1502     if(ist->next_pts == AV_NOPTS_VALUE)
1503         ist->next_pts= ist->pts;
1504
1505     if (pkt == NULL) {
1506         /* EOF handling */
1507         av_init_packet(&avpkt);
1508         avpkt.data = NULL;
1509         avpkt.size = 0;
1510         goto handle_eof;
1511     } else {
1512         avpkt = *pkt;
1513     }
1514
1515     if(pkt->dts != AV_NOPTS_VALUE)
1516         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1517     if(pkt->pts != AV_NOPTS_VALUE)
1518         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1519
1520     //while we have more to decode or while the decoder did output something on EOF
1521     while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1522         uint8_t *data_buf, *decoded_data_buf;
1523         int data_size, decoded_data_size;
1524     handle_eof:
1525         ist->pts= ist->next_pts;
1526
1527         if(avpkt.size && avpkt.size != pkt->size &&
1528            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1529             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1530             ist->showed_multi_packet_warning=1;
1531         }
1532
1533         /* decode the packet if needed */
1534         decoded_data_buf = NULL; /* fail safe */
1535         decoded_data_size= 0;
1536         data_buf  = avpkt.data;
1537         data_size = avpkt.size;
1538         subtitle_to_free = NULL;
1539         if (ist->decoding_needed) {
1540             switch(ist->st->codec->codec_type) {
1541             case AVMEDIA_TYPE_AUDIO:{
1542                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1543                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1544                     av_free(samples);
1545                     samples= av_malloc(samples_size);
1546                 }
1547                 decoded_data_size= samples_size;
1548                     /* XXX: could avoid copy if PCM 16 bits with same
1549                        endianness as CPU */
1550                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1551                                             &avpkt);
1552                 if (ret < 0)
1553                     goto fail_decode;
1554                 avpkt.data += ret;
1555                 avpkt.size -= ret;
1556                 data_size   = ret;
1557                 /* Some bug in mpeg audio decoder gives */
1558                 /* decoded_data_size < 0, it seems they are overflows */
1559                 if (decoded_data_size <= 0) {
1560                     /* no audio frame */
1561                     continue;
1562                 }
1563                 decoded_data_buf = (uint8_t *)samples;
1564                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1565                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1566                 break;}
1567             case AVMEDIA_TYPE_VIDEO:
1568                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1569                     /* XXX: allocate picture correctly */
1570                     avcodec_get_frame_defaults(&picture);
1571                     avpkt.pts = pkt_pts;
1572                     avpkt.dts = ist->pts;
1573                     pkt_pts = AV_NOPTS_VALUE;
1574
1575                     ret = avcodec_decode_video2(ist->st->codec,
1576                                                 &picture, &got_picture, &avpkt);
1577                     ist->st->quality= picture.quality;
1578                     if (ret < 0)
1579                         goto fail_decode;
1580                     if (!got_picture) {
1581                         /* no picture yet */
1582                         goto discard_packet;
1583                     }
1584                     ist->next_pts = ist->pts = picture.best_effort_timestamp;
1585                     if (ist->st->codec->time_base.num != 0) {
1586                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1587                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1588                                           ist->st->codec->time_base.num * ticks) /
1589                             ist->st->codec->time_base.den;
1590                     }
1591                     avpkt.size = 0;
1592                     break;
1593             case AVMEDIA_TYPE_SUBTITLE:
1594                 ret = avcodec_decode_subtitle2(ist->st->codec,
1595                                                &subtitle, &got_picture, &avpkt);
1596                 if (ret < 0)
1597                     goto fail_decode;
1598                 if (!got_picture) {
1599                     goto discard_packet;
1600                 }
1601                 subtitle_to_free = &subtitle;
1602                 avpkt.size = 0;
1603                 break;
1604             default:
1605                 goto fail_decode;
1606             }
1607         } else {
1608             switch(ist->st->codec->codec_type) {
1609             case AVMEDIA_TYPE_AUDIO:
1610                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1611                     ist->st->codec->sample_rate;
1612                 break;
1613             case AVMEDIA_TYPE_VIDEO:
1614                 if (ist->st->codec->time_base.num != 0) {
1615                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1616                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1617                                       ist->st->codec->time_base.num * ticks) /
1618                         ist->st->codec->time_base.den;
1619                 }
1620                 break;
1621             }
1622             ret = avpkt.size;
1623             avpkt.size = 0;
1624         }
1625
1626         buffer_to_free = NULL;
1627         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1628             pre_process_video_frame(ist, (AVPicture *)&picture,
1629                                     &buffer_to_free);
1630         }
1631
1632 #if CONFIG_AVFILTER
1633         if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1634             for(i=0;i<nb_ostreams;i++) {
1635                 ost = ost_table[i];
1636                 if (ost->input_video_filter && ost->source_index == ist_index) {
1637                     AVRational sar;
1638                     if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1639                     else                                  sar = ist->st->codec->sample_aspect_ratio;
1640                     // add it to be filtered
1641                     av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture,
1642                                              ist->pts,
1643                                              sar, ist->st->codec->width, ist->st->codec->height,
1644                                              ist->st->codec->pix_fmt, "0:0"); //TODO user setable params
1645                 }
1646             }
1647         }
1648 #endif
1649
1650         // preprocess audio (volume)
1651         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1652             if (audio_volume != 256) {
1653                 short *volp;
1654                 volp = samples;
1655                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1656                     int v = ((*volp) * audio_volume + 128) >> 8;
1657                     if (v < -32768) v = -32768;
1658                     if (v >  32767) v = 32767;
1659                     *volp++ = v;
1660                 }
1661             }
1662         }
1663
1664         /* frame rate emulation */
1665         if (rate_emu) {
1666             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1667             int64_t now = av_gettime() - ist->start;
1668             if (pts > now)
1669                 usleep(pts - now);
1670         }
1671         /* if output time reached then transcode raw format,
1672            encode packets and output them */
1673         if (start_time == 0 || ist->pts >= start_time)
1674             for(i=0;i<nb_ostreams;i++) {
1675                 int frame_size;
1676
1677                 ost = ost_table[i];
1678                 if (ost->source_index == ist_index) {
1679 #if CONFIG_AVFILTER
1680                 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1681                     !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1682                 while (frame_available) {
1683                     AVRational ist_pts_tb;
1684                     if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1685                         get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1686                     if (ost->picref)
1687                         ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1688 #endif
1689                     os = output_files[ost->file_index];
1690
1691                     /* set the input output pts pairs */
1692                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1693
1694                     if (ost->encoding_needed) {
1695                         av_assert0(ist->decoding_needed);
1696                         switch(ost->st->codec->codec_type) {
1697                         case AVMEDIA_TYPE_AUDIO:
1698                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1699                             break;
1700                         case AVMEDIA_TYPE_VIDEO:
1701 #if CONFIG_AVFILTER
1702                             if (ost->picref->video && !ost->frame_aspect_ratio)
1703                                 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1704 #endif
1705                             do_video_out(os, ost, ist, &picture, &frame_size);
1706                             if (vstats_filename && frame_size)
1707                                 do_video_stats(os, ost, frame_size);
1708                             break;
1709                         case AVMEDIA_TYPE_SUBTITLE:
1710                             do_subtitle_out(os, ost, ist, &subtitle,
1711                                             pkt->pts);
1712                             break;
1713                         default:
1714                             abort();
1715                         }
1716                     } else {
1717                         AVFrame avframe; //FIXME/XXX remove this
1718                         AVPacket opkt;
1719                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1720
1721                         av_init_packet(&opkt);
1722
1723                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1724 #if !CONFIG_AVFILTER
1725                             continue;
1726 #else
1727                             goto cont;
1728 #endif
1729
1730                         /* no reencoding needed : output the packet directly */
1731                         /* force the input stream PTS */
1732
1733                         avcodec_get_frame_defaults(&avframe);
1734                         ost->st->codec->coded_frame= &avframe;
1735                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1736
1737                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1738                             audio_size += data_size;
1739                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1740                             video_size += data_size;
1741                             ost->sync_opts++;
1742                         }
1743
1744                         opkt.stream_index= ost->index;
1745                         if(pkt->pts != AV_NOPTS_VALUE)
1746                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1747                         else
1748                             opkt.pts= AV_NOPTS_VALUE;
1749
1750                         if (pkt->dts == AV_NOPTS_VALUE)
1751                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1752                         else
1753                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1754                         opkt.dts -= ost_tb_start_time;
1755
1756                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1757                         opkt.flags= pkt->flags;
1758
1759                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1760                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1761                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1762                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1763                            ) {
1764                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1765                                 opkt.destruct= av_destruct_packet;
1766                         } else {
1767                             opkt.data = data_buf;
1768                             opkt.size = data_size;
1769                         }
1770
1771                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1772                         ost->st->codec->frame_number++;
1773                         ost->frame_number++;
1774                         av_free_packet(&opkt);
1775                     }
1776 #if CONFIG_AVFILTER
1777                     cont:
1778                     frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1779                                        ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1780                     if(ost->picref)
1781                         avfilter_unref_buffer(ost->picref);
1782                 }
1783 #endif
1784                 }
1785             }
1786
1787         av_free(buffer_to_free);
1788         /* XXX: allocate the subtitles in the codec ? */
1789         if (subtitle_to_free) {
1790             avsubtitle_free(subtitle_to_free);
1791             subtitle_to_free = NULL;
1792         }
1793     }
1794  discard_packet:
1795     if (pkt == NULL) {
1796         /* EOF handling */
1797
1798         for(i=0;i<nb_ostreams;i++) {
1799             ost = ost_table[i];
1800             if (ost->source_index == ist_index) {
1801                 AVCodecContext *enc= ost->st->codec;
1802                 os = output_files[ost->file_index];
1803
1804                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1805                     continue;
1806                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1807                     continue;
1808
1809                 if (ost->encoding_needed) {
1810                     for(;;) {
1811                         AVPacket pkt;
1812                         int fifo_bytes;
1813                         av_init_packet(&pkt);
1814                         pkt.stream_index= ost->index;
1815
1816                         switch(ost->st->codec->codec_type) {
1817                         case AVMEDIA_TYPE_AUDIO:
1818                             fifo_bytes = av_fifo_size(ost->fifo);
1819                             ret = 0;
1820                             /* encode any samples remaining in fifo */
1821                             if (fifo_bytes > 0) {
1822                                 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1823                                 int fs_tmp = enc->frame_size;
1824
1825                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1826                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1827                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1828                                 } else { /* pad */
1829                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1830                                     if (allocated_audio_buf_size < frame_bytes)
1831                                         ffmpeg_exit(1);
1832                                     generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1833                                 }
1834
1835                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1836                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1837                                                           ost->st->time_base.num, enc->sample_rate);
1838                                 enc->frame_size = fs_tmp;
1839                             }
1840                             if(ret <= 0) {
1841                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1842                             }
1843                             if (ret < 0) {
1844                                 fprintf(stderr, "Audio encoding failed\n");
1845                                 ffmpeg_exit(1);
1846                             }
1847                             audio_size += ret;
1848                             pkt.flags |= AV_PKT_FLAG_KEY;
1849                             break;
1850                         case AVMEDIA_TYPE_VIDEO:
1851                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1852                             if (ret < 0) {
1853                                 fprintf(stderr, "Video encoding failed\n");
1854                                 ffmpeg_exit(1);
1855                             }
1856                             video_size += ret;
1857                             if(enc->coded_frame && enc->coded_frame->key_frame)
1858                                 pkt.flags |= AV_PKT_FLAG_KEY;
1859                             if (ost->logfile && enc->stats_out) {
1860                                 fprintf(ost->logfile, "%s", enc->stats_out);
1861                             }
1862                             break;
1863                         default:
1864                             ret=-1;
1865                         }
1866
1867                         if(ret<=0)
1868                             break;
1869                         pkt.data= bit_buffer;
1870                         pkt.size= ret;
1871                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1872                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1873                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1874                     }
1875                 }
1876             }
1877         }
1878     }
1879
1880     return 0;
1881  fail_decode:
1882     return -1;
1883 }
1884
1885 static void print_sdp(AVFormatContext **avc, int n)
1886 {
1887     char sdp[2048];
1888
1889     av_sdp_create(avc, n, sdp, sizeof(sdp));
1890     printf("SDP:\n%s\n", sdp);
1891     fflush(stdout);
1892 }
1893
1894 static int copy_chapters(int infile, int outfile)
1895 {
1896     AVFormatContext *is = input_files[infile];
1897     AVFormatContext *os = output_files[outfile];
1898     int i;
1899
1900     for (i = 0; i < is->nb_chapters; i++) {
1901         AVChapter *in_ch = is->chapters[i], *out_ch;
1902         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1903                                       AV_TIME_BASE_Q, in_ch->time_base);
1904         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1905                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1906
1907
1908         if (in_ch->end < ts_off)
1909             continue;
1910         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1911             break;
1912
1913         out_ch = av_mallocz(sizeof(AVChapter));
1914         if (!out_ch)
1915             return AVERROR(ENOMEM);
1916
1917         out_ch->id        = in_ch->id;
1918         out_ch->time_base = in_ch->time_base;
1919         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1920         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1921
1922         if (metadata_chapters_autocopy)
1923             av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1924
1925         os->nb_chapters++;
1926         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1927         if (!os->chapters)
1928             return AVERROR(ENOMEM);
1929         os->chapters[os->nb_chapters - 1] = out_ch;
1930     }
1931     return 0;
1932 }
1933
1934 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1935                                     AVCodecContext *avctx)
1936 {
1937     char *p;
1938     int n = 1, i;
1939     int64_t t;
1940
1941     for (p = kf; *p; p++)
1942         if (*p == ',')
1943             n++;
1944     ost->forced_kf_count = n;
1945     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1946     if (!ost->forced_kf_pts) {
1947         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1948         ffmpeg_exit(1);
1949     }
1950     for (i = 0; i < n; i++) {
1951         p = i ? strchr(p, ',') + 1 : kf;
1952         t = parse_time_or_die("force_key_frames", p, 1);
1953         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1954     }
1955 }
1956
1957 /*
1958  * The following code is the main loop of the file converter
1959  */
1960 static int transcode(AVFormatContext **output_files,
1961                      int nb_output_files,
1962                      AVFormatContext **input_files,
1963                      int nb_input_files,
1964                      AVStreamMap *stream_maps, int nb_stream_maps)
1965 {
1966     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
1967     AVFormatContext *is, *os;
1968     AVCodecContext *codec, *icodec;
1969     AVOutputStream *ost, **ost_table = NULL;
1970     AVInputStream *ist, **ist_table = NULL;
1971     AVInputFile *file_table;
1972     char error[1024];
1973     int key;
1974     int want_sdp = 1;
1975     uint8_t no_packet[MAX_FILES]={0};
1976     int no_packet_count=0;
1977     int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1978     int nb_streams[AVMEDIA_TYPE_NB]={0};
1979
1980     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1981     if (!file_table)
1982         goto fail;
1983
1984     /* input stream init */
1985     j = 0;
1986     for(i=0;i<nb_input_files;i++) {
1987         is = input_files[i];
1988         file_table[i].ist_index = j;
1989         file_table[i].nb_streams = is->nb_streams;
1990         j += is->nb_streams;
1991     }
1992     nb_istreams = j;
1993
1994     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1995     if (!ist_table)
1996         goto fail;
1997
1998     for(i=0;i<nb_istreams;i++) {
1999         ist = av_mallocz(sizeof(AVInputStream));
2000         if (!ist)
2001             goto fail;
2002         ist_table[i] = ist;
2003     }
2004     j = 0;
2005     for(i=0;i<nb_input_files;i++) {
2006         is = input_files[i];
2007         for(k=0;k<is->nb_streams;k++) {
2008             ist = ist_table[j++];
2009             ist->st = is->streams[k];
2010             ist->file_index = i;
2011             ist->index = k;
2012             ist->discard = 1; /* the stream is discarded by default
2013                                  (changed later) */
2014
2015             if (rate_emu) {
2016                 ist->start = av_gettime();
2017             }
2018         }
2019     }
2020
2021     /* output stream init */
2022     nb_ostreams = 0;
2023     for(i=0;i<nb_output_files;i++) {
2024         os = output_files[i];
2025         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2026             av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2027             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2028             ret = AVERROR(EINVAL);
2029             goto fail;
2030         }
2031         nb_ostreams += os->nb_streams;
2032     }
2033     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2034         fprintf(stderr, "Number of stream maps must match number of output streams\n");
2035         ret = AVERROR(EINVAL);
2036         goto fail;
2037     }
2038
2039     /* Sanity check the mapping args -- do the input files & streams exist? */
2040     for(i=0;i<nb_stream_maps;i++) {
2041         int fi = stream_maps[i].file_index;
2042         int si = stream_maps[i].stream_index;
2043
2044         if (fi < 0 || fi > nb_input_files - 1 ||
2045             si < 0 || si > file_table[fi].nb_streams - 1) {
2046             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2047             ret = AVERROR(EINVAL);
2048             goto fail;
2049         }
2050         fi = stream_maps[i].sync_file_index;
2051         si = stream_maps[i].sync_stream_index;
2052         if (fi < 0 || fi > nb_input_files - 1 ||
2053             si < 0 || si > file_table[fi].nb_streams - 1) {
2054             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2055             ret = AVERROR(EINVAL);
2056             goto fail;
2057         }
2058     }
2059
2060     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2061     if (!ost_table)
2062         goto fail;
2063
2064     for(k=0;k<nb_output_files;k++) {
2065         os = output_files[k];
2066         for(i=0;i<os->nb_streams;i++,n++) {
2067             nb_streams[os->streams[i]->codec->codec_type]++;
2068         }
2069     }
2070     for(step=1<<30; step; step>>=1){
2071         int found_streams[AVMEDIA_TYPE_NB]={0};
2072         for(j=0; j<AVMEDIA_TYPE_NB; j++)
2073             nb_frame_threshold[j] += step;
2074
2075         for(j=0; j<nb_istreams; j++) {
2076             int skip=0;
2077             ist = ist_table[j];
2078             if(opt_programid){
2079                 int pi,si;
2080                 AVFormatContext *f= input_files[ ist->file_index ];
2081                 skip=1;
2082                 for(pi=0; pi<f->nb_programs; pi++){
2083                     AVProgram *p= f->programs[pi];
2084                     if(p->id == opt_programid)
2085                         for(si=0; si<p->nb_stream_indexes; si++){
2086                             if(f->streams[ p->stream_index[si] ] == ist->st)
2087                                 skip=0;
2088                         }
2089                 }
2090             }
2091             if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2092                 && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2093                 found_streams[ist->st->codec->codec_type]++;
2094             }
2095         }
2096         for(j=0; j<AVMEDIA_TYPE_NB; j++)
2097             if(found_streams[j] < nb_streams[j])
2098                 nb_frame_threshold[j] -= step;
2099     }
2100     n = 0;
2101     for(k=0;k<nb_output_files;k++) {
2102         os = output_files[k];
2103         for(i=0;i<os->nb_streams;i++,n++) {
2104             int found;
2105             ost = ost_table[n] = output_streams_for_file[k][i];
2106             ost->st = os->streams[i];
2107             if (nb_stream_maps > 0) {
2108                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2109                     stream_maps[n].stream_index;
2110
2111                 /* Sanity check that the stream types match */
2112                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2113                     int i= ost->file_index;
2114                     av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2115                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2116                         stream_maps[n].file_index, stream_maps[n].stream_index,
2117                         ost->file_index, ost->index);
2118                     ffmpeg_exit(1);
2119                 }
2120
2121             } else {
2122                 /* get corresponding input stream index : we select the first one with the right type */
2123                 found = 0;
2124                 for(j=0;j<nb_istreams;j++) {
2125                     int skip=0;
2126                     ist = ist_table[j];
2127                     if(opt_programid){
2128                         int pi,si;
2129                         AVFormatContext *f= input_files[ ist->file_index ];
2130                         skip=1;
2131                         for(pi=0; pi<f->nb_programs; pi++){
2132                             AVProgram *p= f->programs[pi];
2133                             if(p->id == opt_programid)
2134                                 for(si=0; si<p->nb_stream_indexes; si++){
2135                                     if(f->streams[ p->stream_index[si] ] == ist->st)
2136                                         skip=0;
2137                                 }
2138                         }
2139                     }
2140                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2141                         ist->st->codec->codec_type == ost->st->codec->codec_type &&
2142                         nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2143                             ost->source_index = j;
2144                             found = 1;
2145                             break;
2146                     }
2147                 }
2148
2149                 if (!found) {
2150                     if(! opt_programid) {
2151                         /* try again and reuse existing stream */
2152                         for(j=0;j<nb_istreams;j++) {
2153                             ist = ist_table[j];
2154                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2155                                 && ist->st->discard != AVDISCARD_ALL) {
2156                                 ost->source_index = j;
2157                                 found = 1;
2158                             }
2159                         }
2160                     }
2161                     if (!found) {
2162                         int i= ost->file_index;
2163                         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2164                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2165                                 ost->file_index, ost->index);
2166                         ffmpeg_exit(1);
2167                     }
2168                 }
2169             }
2170             ist = ist_table[ost->source_index];
2171             ist->discard = 0;
2172             ost->sync_ist = (nb_stream_maps > 0) ?
2173                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2174                          stream_maps[n].sync_stream_index] : ist;
2175         }
2176     }
2177
2178     /* for each output stream, we compute the right encoding parameters */
2179     for(i=0;i<nb_ostreams;i++) {
2180         ost = ost_table[i];
2181         os = output_files[ost->file_index];
2182         ist = ist_table[ost->source_index];
2183
2184         codec = ost->st->codec;
2185         icodec = ist->st->codec;
2186
2187         if (metadata_streams_autocopy)
2188             av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2189                              AV_METADATA_DONT_OVERWRITE);
2190
2191         ost->st->disposition = ist->st->disposition;
2192         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2193         codec->chroma_sample_location = icodec->chroma_sample_location;
2194
2195         if (ost->st->stream_copy) {
2196             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2197
2198             if (extra_size > INT_MAX)
2199                 goto fail;
2200
2201             /* if stream_copy is selected, no need to decode or encode */
2202             codec->codec_id = icodec->codec_id;
2203             codec->codec_type = icodec->codec_type;
2204
2205             if(!codec->codec_tag){
2206                 if(   !os->oformat->codec_tag
2207                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2208                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2209                     codec->codec_tag = icodec->codec_tag;
2210             }
2211
2212             codec->bit_rate = icodec->bit_rate;
2213             codec->rc_max_rate    = icodec->rc_max_rate;
2214             codec->rc_buffer_size = icodec->rc_buffer_size;
2215             codec->extradata= av_mallocz(extra_size);
2216             if (!codec->extradata)
2217                 goto fail;
2218             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2219             codec->extradata_size= icodec->extradata_size;
2220             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){
2221                 codec->time_base = icodec->time_base;
2222                 codec->time_base.num *= icodec->ticks_per_frame;
2223                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2224                           codec->time_base.num, codec->time_base.den, INT_MAX);
2225             }else
2226                 codec->time_base = ist->st->time_base;
2227             switch(codec->codec_type) {
2228             case AVMEDIA_TYPE_AUDIO:
2229                 if(audio_volume != 256) {
2230                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2231                     ffmpeg_exit(1);
2232                 }
2233                 codec->channel_layout = icodec->channel_layout;
2234                 codec->sample_rate = icodec->sample_rate;
2235                 codec->channels = icodec->channels;
2236                 codec->frame_size = icodec->frame_size;
2237                 codec->audio_service_type = icodec->audio_service_type;
2238                 codec->block_align= icodec->block_align;
2239                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2240                     codec->block_align= 0;
2241                 if(codec->codec_id == CODEC_ID_AC3)
2242                     codec->block_align= 0;
2243                 break;
2244             case AVMEDIA_TYPE_VIDEO:
2245                 codec->pix_fmt = icodec->pix_fmt;
2246                 codec->width = icodec->width;
2247                 codec->height = icodec->height;
2248                 codec->has_b_frames = icodec->has_b_frames;
2249                 if (!codec->sample_aspect_ratio.num) {
2250                     codec->sample_aspect_ratio =
2251                     ost->st->sample_aspect_ratio =
2252                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2253                         ist->st->codec->sample_aspect_ratio.num ?
2254                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2255                 }
2256                 break;
2257             case AVMEDIA_TYPE_SUBTITLE:
2258                 codec->width = icodec->width;
2259                 codec->height = icodec->height;
2260                 break;
2261             default:
2262                 abort();
2263             }
2264         } else {
2265             switch(codec->codec_type) {
2266             case AVMEDIA_TYPE_AUDIO:
2267                 ost->fifo= av_fifo_alloc(1024);
2268                 if(!ost->fifo)
2269                     goto fail;
2270                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2271                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2272                 icodec->request_channels = codec->channels;
2273                 ist->decoding_needed = 1;
2274                 ost->encoding_needed = 1;
2275                 ost->resample_sample_fmt  = icodec->sample_fmt;
2276                 ost->resample_sample_rate = icodec->sample_rate;
2277                 ost->resample_channels    = icodec->channels;
2278                 break;
2279             case AVMEDIA_TYPE_VIDEO:
2280                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2281                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2282                     ffmpeg_exit(1);
2283                 }
2284                 ost->video_resample = (codec->width != icodec->width   ||
2285                                        codec->height != icodec->height ||
2286                         (codec->pix_fmt != icodec->pix_fmt));
2287                 if (ost->video_resample) {
2288 #if !CONFIG_AVFILTER
2289                     avcodec_get_frame_defaults(&ost->pict_tmp);
2290                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2291                                          codec->width, codec->height)) {
2292                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2293                         ffmpeg_exit(1);
2294                     }
2295                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2296                     ost->img_resample_ctx = sws_getContext(
2297                         icodec->width,
2298                         icodec->height,
2299                             icodec->pix_fmt,
2300                             codec->width,
2301                             codec->height,
2302                             codec->pix_fmt,
2303                             sws_flags, NULL, NULL, NULL);
2304                     if (ost->img_resample_ctx == NULL) {
2305                         fprintf(stderr, "Cannot get resampling context\n");
2306                         ffmpeg_exit(1);
2307                     }
2308
2309                     ost->original_height = icodec->height;
2310                     ost->original_width  = icodec->width;
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 const OptionDef options[] = {
4270     /* main options */
4271 #include "cmdutils_common_opts.h"
4272     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4273     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4274     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4275     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4276     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4277       "outfile[,metadata]:infile[,metadata]" },
4278     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4279       "outfile[,metadata]:infile[,metadata]" },
4280     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4281     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4282     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4283     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4284     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4285     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4286     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4287     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4288     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4289     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4290       "add timings for benchmarking" },
4291     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4292     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4293       "dump each input packet" },
4294     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4295       "when dumping packets, also dump the payload" },
4296     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4297     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4298     { "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)", "" },
4299     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4300     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4301     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4302     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4303     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4304     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4305     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4306     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4307     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4308     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4309     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4310     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4311     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4312     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4313
4314     /* video options */
4315     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4316     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4317     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4318     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4319     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4320     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4321     { "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" },
4322     { "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" },
4323     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4324     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4325     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4326     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4327     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4328     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4329     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4330     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4331     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4332     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4333     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4334     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4335     { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4336     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4337     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4338     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4339     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4340       "use same quantizer as source (implies VBR)" },
4341     { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4342     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4343     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4344       "deinterlace pictures" },
4345     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4346     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4347     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4348 #if CONFIG_AVFILTER
4349     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4350 #endif
4351     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4352     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4353     { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4354     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4355     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4356     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4357     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4358     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4359     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4360     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4361     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4362
4363     /* audio options */
4364     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4365     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4366     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4367     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4368     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4369     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4370     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4371     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4372     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4373     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4374     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4375     { "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" },
4376
4377     /* subtitle options */
4378     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4379     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4380     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4381     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4382     { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4383
4384     /* grab options */
4385     { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4386     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4387     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4388
4389     /* muxer options */
4390     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4391     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4392
4393     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4394     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4395     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4396
4397     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4398     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4399     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4400     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4401
4402     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4403     { NULL, },
4404 };
4405
4406 int main(int argc, char **argv)
4407 {
4408     int64_t ti;
4409
4410     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4411
4412     avcodec_register_all();
4413 #if CONFIG_AVDEVICE
4414     avdevice_register_all();
4415 #endif
4416 #if CONFIG_AVFILTER
4417     avfilter_register_all();
4418 #endif
4419     av_register_all();
4420
4421 #if HAVE_ISATTY
4422     if(isatty(STDIN_FILENO))
4423         avio_set_interrupt_cb(decode_interrupt_cb);
4424 #endif
4425
4426     init_opts();
4427
4428     show_banner();
4429
4430     /* parse options */
4431     parse_options(argc, argv, options, opt_output_file);
4432
4433     if(nb_output_files <= 0 && nb_input_files == 0) {
4434         show_usage();
4435         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4436         ffmpeg_exit(1);
4437     }
4438
4439     /* file converter / grab */
4440     if (nb_output_files <= 0) {
4441         fprintf(stderr, "At least one output file must be specified\n");
4442         ffmpeg_exit(1);
4443     }
4444
4445     if (nb_input_files == 0) {
4446         fprintf(stderr, "At least one input file must be specified\n");
4447         ffmpeg_exit(1);
4448     }
4449
4450     ti = getutime();
4451     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4452                   stream_maps, nb_stream_maps) < 0)
4453         ffmpeg_exit(1);
4454     ti = getutime() - ti;
4455     if (do_benchmark) {
4456         int maxrss = getmaxrss() / 1024;
4457         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4458     }
4459
4460     return ffmpeg_exit(0);
4461 }