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