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