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

   1 /*
   2  * FFmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /* needed for usleep() */
  23 #define _XOPEN_SOURCE 600
  24
  25 #include "config.h"
  26 #include <ctype.h>
  27 #include <string.h>
  28 #include <math.h>
  29 #include <stdlib.h>
  30 #include <errno.h>
  31 #include <signal.h>
  32 #include <limits.h>
  33 #include <unistd.h>
  34 #include "libavformat/avformat.h"
  35 #include "libavdevice/avdevice.h"
  36 #include "libswscale/swscale.h"
  37 #include "libavcodec/opt.h"
  38 #include "libavcodec/audioconvert.h"
  39 #include "libavutil/audioconvert.h"
  40 #include "libavutil/parseutils.h"
  41 #include "libavutil/samplefmt.h"
  42 #include "libavutil/colorspace.h"
  43 #include "libavutil/fifo.h"
  44 #include "libavutil/intreadwrite.h"
  45 #include "libavutil/pixdesc.h"
  46 #include "libavutil/avstring.h"
  47 #include "libavutil/libm.h"
  48 #include "libavformat/os_support.h"
  49
  50 #include "libavformat/ffm.h" // not public API
  51
  52 #if CONFIG_AVFILTER
  53 # include "libavfilter/avfilter.h"
  54 # include "libavfilter/avfiltergraph.h"
  55 # include "libavfilter/vsrc_buffer.h"
  56 #endif
  57
  58 #if HAVE_SYS_RESOURCE_H
  59 #include <sys/types.h>
  60 #include <sys/time.h>
  61 #include <sys/resource.h>
  62 #elif HAVE_GETPROCESSTIMES
  63 #include <windows.h>
  64 #endif
  65 #if HAVE_GETPROCESSMEMORYINFO
  66 #include <windows.h>
  67 #include <psapi.h>
  68 #endif
  69
  70 #if HAVE_SYS_SELECT_H
  71 #include <sys/select.h>
  72 #endif
  73
  74 #if HAVE_TERMIOS_H
  75 #include <fcntl.h>
  76 #include <sys/ioctl.h>
  77 #include <sys/time.h>
  78 #include <termios.h>
  79 #elif HAVE_KBHIT
  80 #include <conio.h>
  81 #endif
  82 #include <time.h>
  83
  84 #include "cmdutils.h"
  85
  86 #include "libavutil/avassert.h"
  87
  88 const char program_name[] = "FFmpeg";
  89 const int program_birth_year = 2000;
  90
  91 /* select an input stream for an output stream */
  92 typedef struct AVStreamMap {
  93     int file_index;
  94     int stream_index;
  95     int sync_file_index;
  96     int sync_stream_index;
  97 } AVStreamMap;
  98
  99 /**
 100  * select an input file for an output file
 101  */
 102 typedef struct AVMetaDataMap {
 103     int  file;      //< file index
 104     char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
 105     int  index;     //< stream/chapter/program number
 106 } AVMetaDataMap;
 107
 108 typedef struct AVChapterMap {
 109     int in_file;
 110     int out_file;
 111 } AVChapterMap;
 112
 113 static const OptionDef options[];
 114
 115 #define MAX_FILES 100
 116 #if !FF_API_MAX_STREAMS
 117 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
 118 #endif
 119
 120 static const char *last_asked_format = NULL;
 121 static AVFormatContext *input_files[MAX_FILES];
 122 static int64_t input_files_ts_offset[MAX_FILES];
 123 static double *input_files_ts_scale[MAX_FILES] = {NULL};
 124 static AVCodec **input_codecs = NULL;
 125 static int nb_input_files = 0;
 126 static int nb_input_codecs = 0;
 127 static int nb_input_files_ts_scale[MAX_FILES] = {0};
 128
 129 static AVFormatContext *output_files[MAX_FILES];
 130 static AVCodec **output_codecs = NULL;
 131 static int nb_output_files = 0;
 132 static int nb_output_codecs = 0;
 133
 134 static AVStreamMap *stream_maps = NULL;
 135 static int nb_stream_maps;
 136
 137 /* first item specifies output metadata, second is input */
 138 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
 139 static int nb_meta_data_maps;
 140 static int metadata_global_autocopy   = 1;
 141 static int metadata_streams_autocopy  = 1;
 142 static int metadata_chapters_autocopy = 1;
 143
 144 static AVChapterMap *chapter_maps = NULL;
 145 static int nb_chapter_maps;
 146
 147 /* indexed by output file stream index */
 148 static int *streamid_map = NULL;
 149 static int nb_streamid_map = 0;
 150
 151 static int frame_width  = 0;
 152 static int frame_height = 0;
 153 static float frame_aspect_ratio = 0;
 154 static int frame_aspect_ratio_override = 0;
 155 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 156 static int frame_bits_per_raw_sample = 0;
 157 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
 158 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 159 static AVRational frame_rate;
 160 static float video_qscale = 0;
 161 static uint16_t *intra_matrix = NULL;
 162 static uint16_t *inter_matrix = NULL;
 163 static const char *video_rc_override_string=NULL;
 164 static int video_disable = 0;
 165 static int video_discard = 0;
 166 static char *video_codec_name = NULL;
 167 static unsigned int video_codec_tag = 0;
 168 static char *video_language = NULL;
 169 static int same_quality = 0;
 170 static int do_deinterlace = 0;
 171 static int top_field_first = -1;
 172 static int me_threshold = 0;
 173 static int intra_dc_precision = 8;
 174 static int loop_input = 0;
 175 static int loop_output = AVFMT_NOOUTPUTLOOP;
 176 static int qp_hist = 0;
 177 #if CONFIG_AVFILTER
 178 static char *vfilters = NULL;
 179 #else
 180 static unsigned int sws_flags = SWS_BICUBIC;
 181 #endif
 182
 183 static int intra_only = 0;
 184 static int audio_sample_rate = 44100;
 185 static int64_t channel_layout = 0;
 186 #define QSCALE_NONE -99999
 187 static float audio_qscale = QSCALE_NONE;
 188 static int audio_disable = 0;
 189 static int audio_channels = 1;
 190 static char  *audio_codec_name = NULL;
 191 static unsigned int audio_codec_tag = 0;
 192 static char *audio_language = NULL;
 193
 194 static int subtitle_disable = 0;
 195 static char *subtitle_codec_name = NULL;
 196 static char *subtitle_language = NULL;
 197 static unsigned int subtitle_codec_tag = 0;
 198
 199 static float mux_preload= 0.5;
 200 static float mux_max_delay= 0.7;
 201
 202 static int64_t recording_time = INT64_MAX;
 203 static int64_t start_time = 0;
 204 static int64_t recording_timestamp = 0;
 205 static int64_t input_ts_offset = 0;
 206 static int file_overwrite = 0;
 207 static AVMetadata *metadata;
 208 static int do_benchmark = 0;
 209 static int do_hex_dump = 0;
 210 static int do_pkt_dump = 0;
 211 static int do_psnr = 0;
 212 static int do_pass = 0;
 213 static char *pass_logfilename_prefix = NULL;
 214 static int audio_stream_copy = 0;
 215 static int video_stream_copy = 0;
 216 static int subtitle_stream_copy = 0;
 217 static int video_sync_method= -1;
 218 static int audio_sync_method= 0;
 219 static float audio_drift_threshold= 0.1;
 220 static int copy_ts= 0;
 221 static int copy_tb;
 222 static int opt_shortest = 0;
 223 static int video_global_header = 0;
 224 static char *vstats_filename;
 225 static FILE *vstats_file;
 226 static int opt_programid = 0;
 227 static int copy_initial_nonkeyframes = 0;
 228
 229 static int rate_emu = 0;
 230
 231 static int  video_channel = 0;
 232 static char *video_standard;
 233
 234 static int audio_volume = 256;
 235
 236 static int exit_on_error = 0;
 237 static int using_stdin = 0;
 238 static int verbose = 1;
 239 static int thread_count= 1;
 240 static int q_pressed = 0;
 241 static int64_t video_size = 0;
 242 static int64_t audio_size = 0;
 243 static int64_t extra_size = 0;
 244 static int nb_frames_dup = 0;
 245 static int nb_frames_drop = 0;
 246 static int input_sync;
 247 static uint64_t limit_filesize = 0;
 248 static int force_fps = 0;
 249 static char *forced_key_frames = NULL;
 250
 251 static float dts_delta_threshold = 10;
 252
 253 static int64_t timer_start;
 254
 255 static uint8_t *audio_buf;
 256 static uint8_t *audio_out;
 257 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
 258
 259 static short *samples;
 260
 261 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 262 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 263 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 264
 265 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
 266
 267 struct AVInputStream;
 268
 269 typedef struct AVOutputStream {
 270     int file_index;          /* file index */
 271     int index;               /* stream index in the output file */
 272     int source_index;        /* AVInputStream index */
 273     AVStream *st;            /* stream in the output file */
 274     int encoding_needed;     /* true if encoding needed for this stream */
 275     int frame_number;
 276     /* input pts and corresponding output pts
 277        for A/V sync */
 278     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 279     struct AVInputStream *sync_ist; /* input stream to sync against */
 280     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 281     AVBitStreamFilterContext *bitstream_filters;
 282     /* video only */
 283     int video_resample;
 284     AVFrame pict_tmp;      /* temporary image for resampling */
 285     struct SwsContext *img_resample_ctx; /* for image resampling */
 286     int resample_height;
 287     int resample_width;
 288     int resample_pix_fmt;
 289
 290     /* full frame size of first frame */
 291     int original_height;
 292     int original_width;
 293
 294     /* forced key frames */
 295     int64_t *forced_kf_pts;
 296     int forced_kf_count;
 297     int forced_kf_index;
 298
 299     /* audio only */
 300     int audio_resample;
 301     ReSampleContext *resample; /* for audio resampling */
 302     int resample_sample_fmt;
 303     int resample_channels;
 304     int resample_sample_rate;
 305     int reformat_pair;
 306     AVAudioConvert *reformat_ctx;
 307     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 308     FILE *logfile;
 309
 310 #if CONFIG_AVFILTER
 311     AVFilterContext *output_video_filter;
 312     AVFilterContext *input_video_filter;
 313     AVFilterBufferRef *picref;
 314     char *avfilter;
 315     AVFilterGraph *graph;
 316 #endif
 317 } AVOutputStream;
 318
 319 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
 320 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
 321
 322 typedef struct AVInputStream {
 323     int file_index;
 324     int index;
 325     AVStream *st;
 326     int discard;             /* true if stream data should be discarded */
 327     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 328     int64_t sample_index;      /* current sample */
 329
 330     int64_t       start;     /* time when read started */
 331     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 332                                 is not defined */
 333     int64_t       pts;       /* current pts */
 334     int is_start;            /* is 1 at the start and after a discontinuity */
 335     int showed_multi_packet_warning;
 336     int is_past_recording_time;
 337 #if CONFIG_AVFILTER
 338     AVFrame *filter_frame;
 339     int has_filter_frame;
 340 #endif
 341 } AVInputStream;
 342
 343 typedef struct AVInputFile {
 344     int eof_reached;      /* true if eof reached */
 345     int ist_index;        /* index of first stream in ist_table */
 346     int buffer_size;      /* current total buffer size */
 347     int nb_streams;       /* nb streams we are aware of */
 348 } AVInputFile;
 349
 350 #if HAVE_TERMIOS_H
 351
 352 /* init terminal so that we can grab keys */
 353 static struct termios oldtty;
 354 #endif
 355
 356 #if CONFIG_AVFILTER
 357
 358 static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
 359 {
 360     AVFilterContext *last_filter, *filter;
 361     /** filter graph containing all filters including input & output */
 362     AVCodecContext *codec = ost->st->codec;
 363     AVCodecContext *icodec = ist->st->codec;
 364     FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
 365     AVRational sample_aspect_ratio;
 366     char args[255];
 367     int ret;
 368
 369     ost->graph = avfilter_graph_alloc();
 370
 371     if (ist->st->sample_aspect_ratio.num){
 372         sample_aspect_ratio = ist->st->sample_aspect_ratio;
 373     }else
 374         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
 375
 376     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
 377              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 378              sample_aspect_ratio.num, sample_aspect_ratio.den);
 379
 380     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
 381                                        "src", args, NULL, ost->graph);
 382     if (ret < 0)
 383         return ret;
 384     ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
 385                                        "out", NULL, &ffsink_ctx, ost->graph);
 386     if (ret < 0)
 387         return ret;
 388     last_filter = ost->input_video_filter;
 389
 390     if (codec->width  != icodec->width || codec->height != icodec->height) {
 391         snprintf(args, 255, "%d:%d:flags=0x%X",
 392                  codec->width,
 393                  codec->height,
 394                  (int)av_get_int(sws_opts, "sws_flags", NULL));
 395         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 396                                                 NULL, args, NULL, ost->graph)) < 0)
 397             return ret;
 398         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
 399             return ret;
 400         last_filter = filter;
 401     }
 402
 403     snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
 404     ost->graph->scale_sws_opts = av_strdup(args);
 405
 406     if (ost->avfilter) {
 407         AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
 408         AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
 409
 410         outputs->name    = av_strdup("in");
 411         outputs->filter_ctx = last_filter;
 412         outputs->pad_idx = 0;
 413         outputs->next    = NULL;
 414
 415         inputs->name    = av_strdup("out");
 416         inputs->filter_ctx = ost->output_video_filter;
 417         inputs->pad_idx = 0;
 418         inputs->next    = NULL;
 419
 420         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
 421             return ret;
 422         av_freep(&ost->avfilter);
 423     } else {
 424         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
 425             return ret;
 426     }
 427
 428     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
 429         return ret;
 430
 431     codec->width  = ost->output_video_filter->inputs[0]->w;
 432     codec->height = ost->output_video_filter->inputs[0]->h;
 433     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
 434         ost->output_video_filter->inputs[0]->sample_aspect_ratio;
 435
 436     return 0;
 437 }
 438 #endif /* CONFIG_AVFILTER */
 439
 440 static void term_exit(void)
 441 {
 442     av_log(NULL, AV_LOG_QUIET, "");
 443 #if HAVE_TERMIOS_H
 444     tcsetattr (0, TCSANOW, &oldtty);
 445 #endif
 446 }
 447
 448 static volatile int received_sigterm = 0;
 449
 450 static void
 451 sigterm_handler(int sig)
 452 {
 453     received_sigterm = sig;
 454     q_pressed++;
 455     term_exit();
 456 }
 457
 458 static void term_init(void)
 459 {
 460 #if HAVE_TERMIOS_H
 461     struct termios tty;
 462
 463     tcgetattr (0, &tty);
 464     oldtty = tty;
 465     atexit(term_exit);
 466
 467     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 468                           |INLCR|IGNCR|ICRNL|IXON);
 469     tty.c_oflag |= OPOST;
 470     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 471     tty.c_cflag &= ~(CSIZE|PARENB);
 472     tty.c_cflag |= CS8;
 473     tty.c_cc[VMIN] = 1;
 474     tty.c_cc[VTIME] = 0;
 475
 476     tcsetattr (0, TCSANOW, &tty);
 477     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 478 #endif
 479
 480     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 481     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 482 #ifdef SIGXCPU
 483     signal(SIGXCPU, sigterm_handler);
 484 #endif
 485 }
 486
 487 /* read a key without blocking */
 488 static int read_key(void)
 489 {
 490 #if HAVE_TERMIOS_H
 491     int n = 1;
 492     unsigned char ch;
 493     struct timeval tv;
 494     fd_set rfds;
 495
 496     FD_ZERO(&rfds);
 497     FD_SET(0, &rfds);
 498     tv.tv_sec = 0;
 499     tv.tv_usec = 0;
 500     n = select(1, &rfds, NULL, NULL, &tv);
 501     if (n > 0) {
 502         n = read(0, &ch, 1);
 503         if (n == 1)
 504             return ch;
 505
 506         return n;
 507     }
 508 #elif HAVE_KBHIT
 509     if(kbhit())
 510         return(getch());
 511 #endif
 512     return -1;
 513 }
 514
 515 static int decode_interrupt_cb(void)
 516 {
 517     q_pressed += read_key() == 'q';
 518     return q_pressed > 1;
 519 }
 520
 521 static int ffmpeg_exit(int ret)
 522 {
 523     int i;
 524
 525     /* close files */
 526     for(i=0;i<nb_output_files;i++) {
 527         AVFormatContext *s = output_files[i];
 528         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 529             avio_close(s->pb);
 530         avformat_free_context(s);
 531         av_free(output_streams_for_file[i]);
 532     }
 533     for(i=0;i<nb_input_files;i++) {
 534         av_close_input_file(input_files[i]);
 535         av_free(input_files_ts_scale[i]);
 536     }
 537
 538     av_free(intra_matrix);
 539     av_free(inter_matrix);
 540
 541     if (vstats_file)
 542         fclose(vstats_file);
 543     av_free(vstats_filename);
 544
 545     av_free(streamid_map);
 546     av_free(input_codecs);
 547     av_free(output_codecs);
 548     av_free(stream_maps);
 549     av_free(meta_data_maps);
 550
 551     av_free(video_codec_name);
 552     av_free(audio_codec_name);
 553     av_free(subtitle_codec_name);
 554
 555     av_free(video_standard);
 556
 557     uninit_opts();
 558     av_free(audio_buf);
 559     av_free(audio_out);
 560     allocated_audio_buf_size= allocated_audio_out_size= 0;
 561     av_free(samples);
 562
 563 #if CONFIG_AVFILTER
 564     avfilter_uninit();
 565 #endif
 566
 567     if (received_sigterm) {
 568         fprintf(stderr,
 569             "Received signal %d: terminating.\n",
 570             (int) received_sigterm);
 571         exit (255);
 572     }
 573
 574     exit(ret); /* not all OS-es handle main() return value */
 575     return ret;
 576 }
 577
 578 /* similar to ff_dynarray_add() and av_fast_realloc() */
 579 static void *grow_array(void *array, int elem_size, int *size, int new_size)
 580 {
 581     if (new_size >= INT_MAX / elem_size) {
 582         fprintf(stderr, "Array too big.\n");
 583         ffmpeg_exit(1);
 584     }
 585     if (*size < new_size) {
 586         uint8_t *tmp = av_realloc(array, new_size*elem_size);
 587         if (!tmp) {
 588             fprintf(stderr, "Could not alloc buffer.\n");
 589             ffmpeg_exit(1);
 590         }
 591         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
 592         *size = new_size;
 593         return tmp;
 594     }
 595     return array;
 596 }
 597
 598 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
 599 {
 600     if(codec && codec->sample_fmts){
 601         const enum AVSampleFormat *p= codec->sample_fmts;
 602         for(; *p!=-1; p++){
 603             if(*p == st->codec->sample_fmt)
 604                 break;
 605         }
 606         if (*p == -1) {
 607             av_log(NULL, AV_LOG_WARNING,
 608                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
 609                    av_get_sample_fmt_name(st->codec->sample_fmt),
 610                    codec->name,
 611                    av_get_sample_fmt_name(codec->sample_fmts[0]));
 612             st->codec->sample_fmt = codec->sample_fmts[0];
 613         }
 614     }
 615 }
 616
 617 static void choose_sample_rate(AVStream *st, AVCodec *codec)
 618 {
 619     if(codec && codec->supported_samplerates){
 620         const int *p= codec->supported_samplerates;
 621         int best=0;
 622         int best_dist=INT_MAX;
 623         for(; *p; p++){
 624             int dist= abs(st->codec->sample_rate - *p);
 625             if(dist < best_dist){
 626                 best_dist= dist;
 627                 best= *p;
 628             }
 629         }
 630         if(best_dist){
 631             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
 632         }
 633         st->codec->sample_rate= best;
 634     }
 635 }
 636
 637 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
 638 {
 639     if(codec && codec->pix_fmts){
 640         const enum PixelFormat *p= codec->pix_fmts;
 641         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
 642             if(st->codec->codec_id==CODEC_ID_MJPEG){
 643                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
 644             }else if(st->codec->codec_id==CODEC_ID_LJPEG){
 645                 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};
 646             }
 647         }
 648         for(; *p!=-1; p++){
 649             if(*p == st->codec->pix_fmt)
 650                 break;
 651         }
 652         if (*p == -1) {
 653             if(st->codec->pix_fmt != PIX_FMT_NONE)
 654             av_log(NULL, AV_LOG_WARNING,
 655                    "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 656                    av_pix_fmt_descriptors[st->codec->pix_fmt].name,
 657                    codec->name,
 658                    av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
 659             st->codec->pix_fmt = codec->pix_fmts[0];
 660         }
 661     }
 662 }
 663
 664 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
 665 {
 666     int idx = oc->nb_streams - 1;
 667     AVOutputStream *ost;
 668
 669     output_streams_for_file[file_idx] =
 670         grow_array(output_streams_for_file[file_idx],
 671                    sizeof(*output_streams_for_file[file_idx]),
 672                    &nb_output_streams_for_file[file_idx],
 673                    oc->nb_streams);
 674     ost = output_streams_for_file[file_idx][idx] =
 675         av_mallocz(sizeof(AVOutputStream));
 676     if (!ost) {
 677         fprintf(stderr, "Could not alloc output stream\n");
 678         ffmpeg_exit(1);
 679     }
 680     ost->file_index = file_idx;
 681     ost->index = idx;
 682     return ost;
 683 }
 684
 685 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
 686 {
 687     int i, err;
 688     AVFormatContext *ic;
 689     int nopts = 0;
 690
 691     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
 692     if (err < 0)
 693         return err;
 694     /* copy stream format */
 695     s->nb_streams = 0;
 696     for(i=0;i<ic->nb_streams;i++) {
 697         AVStream *st;
 698         AVCodec *codec;
 699
 700         s->nb_streams++;
 701
 702         // FIXME: a more elegant solution is needed
 703         st = av_mallocz(sizeof(AVStream));
 704         memcpy(st, ic->streams[i], sizeof(AVStream));
 705         st->codec = avcodec_alloc_context();
 706         if (!st->codec) {
 707             print_error(filename, AVERROR(ENOMEM));
 708             ffmpeg_exit(1);
 709         }
 710         avcodec_copy_context(st->codec, ic->streams[i]->codec);
 711         s->streams[i] = st;
 712
 713         codec = avcodec_find_encoder(st->codec->codec_id);
 714         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 715             if (audio_stream_copy) {
 716                 st->stream_copy = 1;
 717             } else
 718                 choose_sample_fmt(st, codec);
 719         } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 720             if (video_stream_copy) {
 721                 st->stream_copy = 1;
 722             } else
 723                 choose_pixel_fmt(st, codec);
 724         }
 725
 726         if(st->codec->flags & CODEC_FLAG_BITEXACT)
 727             nopts = 1;
 728
 729         new_output_stream(s, nb_output_files);
 730     }
 731
 732     if (!nopts)
 733         s->timestamp = av_gettime();
 734
 735     av_close_input_file(ic);
 736     return 0;
 737 }
 738
 739 static double
 740 get_sync_ipts(const AVOutputStream *ost)
 741 {
 742     const AVInputStream *ist = ost->sync_ist;
 743     return (double)(ist->pts - start_time)/AV_TIME_BASE;
 744 }
 745
 746 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 747     int ret;
 748
 749     while(bsfc){
 750         AVPacket new_pkt= *pkt;
 751         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 752                                           &new_pkt.data, &new_pkt.size,
 753                                           pkt->data, pkt->size,
 754                                           pkt->flags & AV_PKT_FLAG_KEY);
 755         if(a>0){
 756             av_free_packet(pkt);
 757             new_pkt.destruct= av_destruct_packet;
 758         } else if(a<0){
 759             fprintf(stderr, "%s failed for stream %d, codec %s",
 760                     bsfc->filter->name, pkt->stream_index,
 761                     avctx->codec ? avctx->codec->name : "copy");
 762             print_error("", a);
 763             if (exit_on_error)
 764                 ffmpeg_exit(1);
 765         }
 766         *pkt= new_pkt;
 767
 768         bsfc= bsfc->next;
 769     }
 770
 771     ret= av_interleaved_write_frame(s, pkt);
 772     if(ret < 0){
 773         print_error("av_interleaved_write_frame()", ret);
 774         ffmpeg_exit(1);
 775     }
 776 }
 777
 778 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 779
 780 static void do_audio_out(AVFormatContext *s,
 781                          AVOutputStream *ost,
 782                          AVInputStream *ist,
 783                          unsigned char *buf, int size)
 784 {
 785     uint8_t *buftmp;
 786     int64_t audio_out_size, audio_buf_size;
 787     int64_t allocated_for_size= size;
 788
 789     int size_out, frame_bytes, ret, resample_changed;
 790     AVCodecContext *enc= ost->st->codec;
 791     AVCodecContext *dec= ist->st->codec;
 792     int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
 793     int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
 794     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
 795
 796 need_realloc:
 797     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
 798     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
 799     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
 800     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
 801     audio_buf_size*= osize*enc->channels;
 802
 803     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
 804     if(coded_bps > 8*osize)
 805         audio_out_size= audio_out_size * coded_bps / (8*osize);
 806     audio_out_size += FF_MIN_BUFFER_SIZE;
 807
 808     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
 809         fprintf(stderr, "Buffer sizes too large\n");
 810         ffmpeg_exit(1);
 811     }
 812
 813     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
 814     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
 815     if (!audio_buf || !audio_out){
 816         fprintf(stderr, "Out of memory in do_audio_out\n");
 817         ffmpeg_exit(1);
 818     }
 819
 820     if (enc->channels != dec->channels)
 821         ost->audio_resample = 1;
 822
 823     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
 824                        ost->resample_channels    != dec->channels   ||
 825                        ost->resample_sample_rate != dec->sample_rate;
 826
 827     if ((ost->audio_resample && !ost->resample) || resample_changed) {
 828         if (resample_changed) {
 829             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",
 830                    ist->file_index, ist->index,
 831                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
 832                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
 833             ost->resample_sample_fmt  = dec->sample_fmt;
 834             ost->resample_channels    = dec->channels;
 835             ost->resample_sample_rate = dec->sample_rate;
 836             if (ost->resample)
 837                 audio_resample_close(ost->resample);
 838         }
 839         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
 840         if (audio_sync_method <= 1 &&
 841             ost->resample_sample_fmt  == enc->sample_fmt &&
 842             ost->resample_channels    == enc->channels   &&
 843             ost->resample_sample_rate == enc->sample_rate) {
 844             ost->resample = NULL;
 845             ost->audio_resample = 0;
 846         } else {
 847             if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
 848                 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
 849             ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
 850                                                    enc->sample_rate, dec->sample_rate,
 851                                                    enc->sample_fmt,  dec->sample_fmt,
 852                                                    16, 10, 0, 0.8);
 853             if (!ost->resample) {
 854                 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 855                         dec->channels, dec->sample_rate,
 856                         enc->channels, enc->sample_rate);
 857                 ffmpeg_exit(1);
 858             }
 859         }
 860     }
 861
 862 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
 863     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
 864         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
 865         if (ost->reformat_ctx)
 866             av_audio_convert_free(ost->reformat_ctx);
 867         ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
 868                                                    dec->sample_fmt, 1, NULL, 0);
 869         if (!ost->reformat_ctx) {
 870             fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
 871                 av_get_sample_fmt_name(dec->sample_fmt),
 872                 av_get_sample_fmt_name(enc->sample_fmt));
 873             ffmpeg_exit(1);
 874         }
 875         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
 876     }
 877
 878     if(audio_sync_method){
 879         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 880                 - av_fifo_size(ost->fifo)/(enc->channels * 2);
 881         double idelta= delta*dec->sample_rate / enc->sample_rate;
 882         int byte_delta= ((int)idelta)*2*dec->channels;
 883
 884         //FIXME resample delay
 885         if(fabs(delta) > 50){
 886             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 887                 if(byte_delta < 0){
 888                     byte_delta= FFMAX(byte_delta, -size);
 889                     size += byte_delta;
 890                     buf  -= byte_delta;
 891                     if(verbose > 2)
 892                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 893                     if(!size)
 894                         return;
 895                     ist->is_start=0;
 896                 }else{
 897                     static uint8_t *input_tmp= NULL;
 898                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 899
 900                     if(byte_delta > allocated_for_size - size){
 901                         allocated_for_size= byte_delta + (int64_t)size;
 902                         goto need_realloc;
 903                     }
 904                     ist->is_start=0;
 905
 906                     memset(input_tmp, 0, byte_delta);
 907                     memcpy(input_tmp + byte_delta, buf, size);
 908                     buf= input_tmp;
 909                     size += byte_delta;
 910                     if(verbose > 2)
 911                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 912                 }
 913             }else if(audio_sync_method>1){
 914                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 915                 av_assert0(ost->audio_resample);
 916                 if(verbose > 2)
 917                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 918 //                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));
 919                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 920             }
 921         }
 922     }else
 923         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 924                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
 925
 926     if (ost->audio_resample) {
 927         buftmp = audio_buf;
 928         size_out = audio_resample(ost->resample,
 929                                   (short *)buftmp, (short *)buf,
 930                                   size / (dec->channels * isize));
 931         size_out = size_out * enc->channels * osize;
 932     } else {
 933         buftmp = buf;
 934         size_out = size;
 935     }
 936
 937     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
 938         const void *ibuf[6]= {buftmp};
 939         void *obuf[6]= {audio_buf};
 940         int istride[6]= {isize};
 941         int ostride[6]= {osize};
 942         int len= size_out/istride[0];
 943         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
 944             printf("av_audio_convert() failed\n");
 945             if (exit_on_error)
 946                 ffmpeg_exit(1);
 947             return;
 948         }
 949         buftmp = audio_buf;
 950         size_out = len*osize;
 951     }
 952
 953     /* now encode as many frames as possible */
 954     if (enc->frame_size > 1) {
 955         /* output resampled raw samples */
 956         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
 957             fprintf(stderr, "av_fifo_realloc2() failed\n");
 958             ffmpeg_exit(1);
 959         }
 960         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
 961
 962         frame_bytes = enc->frame_size * osize * enc->channels;
 963
 964         while (av_fifo_size(ost->fifo) >= frame_bytes) {
 965             AVPacket pkt;
 966             av_init_packet(&pkt);
 967
 968             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
 969
 970             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 971
 972             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 973                                        (short *)audio_buf);
 974             if (ret < 0) {
 975                 fprintf(stderr, "Audio encoding failed\n");
 976                 ffmpeg_exit(1);
 977             }
 978             audio_size += ret;
 979             pkt.stream_index= ost->index;
 980             pkt.data= audio_out;
 981             pkt.size= ret;
 982             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 983                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 984             pkt.flags |= AV_PKT_FLAG_KEY;
 985             write_frame(s, &pkt, enc, ost->bitstream_filters);
 986
 987             ost->sync_opts += enc->frame_size;
 988         }
 989     } else {
 990         AVPacket pkt;
 991         av_init_packet(&pkt);
 992
 993         ost->sync_opts += size_out / (osize * enc->channels);
 994
 995         /* output a pcm frame */
 996         /* determine the size of the coded buffer */
 997         size_out /= osize;
 998         if (coded_bps)
 999             size_out = size_out*coded_bps/8;
1000
1001         if(size_out > audio_out_size){
1002             fprintf(stderr, "Internal error, buffer size too small\n");
1003             ffmpeg_exit(1);
1004         }
1005
1006         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1007         ret = avcodec_encode_audio(enc, audio_out, size_out,
1008                                    (short *)buftmp);
1009         if (ret < 0) {
1010             fprintf(stderr, "Audio encoding failed\n");
1011             ffmpeg_exit(1);
1012         }
1013         audio_size += ret;
1014         pkt.stream_index= ost->index;
1015         pkt.data= audio_out;
1016         pkt.size= ret;
1017         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1018             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1019         pkt.flags |= AV_PKT_FLAG_KEY;
1020         write_frame(s, &pkt, enc, ost->bitstream_filters);
1021     }
1022 }
1023
1024 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1025 {
1026     AVCodecContext *dec;
1027     AVPicture *picture2;
1028     AVPicture picture_tmp;
1029     uint8_t *buf = 0;
1030
1031     dec = ist->st->codec;
1032
1033     /* deinterlace : must be done before any resize */
1034     if (do_deinterlace) {
1035         int size;
1036
1037         /* create temporary picture */
1038         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1039         buf = av_malloc(size);
1040         if (!buf)
1041             return;
1042
1043         picture2 = &picture_tmp;
1044         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1045
1046         if(avpicture_deinterlace(picture2, picture,
1047                                  dec->pix_fmt, dec->width, dec->height) < 0) {
1048             /* if error, do not deinterlace */
1049             fprintf(stderr, "Deinterlacing failed\n");
1050             av_free(buf);
1051             buf = NULL;
1052             picture2 = picture;
1053         }
1054     } else {
1055         picture2 = picture;
1056     }
1057
1058     if (picture != picture2)
1059         *picture = *picture2;
1060     *bufp = buf;
1061 }
1062
1063 /* we begin to correct av delay at this threshold */
1064 #define AV_DELAY_MAX 0.100
1065
1066 static void do_subtitle_out(AVFormatContext *s,
1067                             AVOutputStream *ost,
1068                             AVInputStream *ist,
1069                             AVSubtitle *sub,
1070                             int64_t pts)
1071 {
1072     static uint8_t *subtitle_out = NULL;
1073     int subtitle_out_max_size = 1024 * 1024;
1074     int subtitle_out_size, nb, i;
1075     AVCodecContext *enc;
1076     AVPacket pkt;
1077
1078     if (pts == AV_NOPTS_VALUE) {
1079         fprintf(stderr, "Subtitle packets must have a pts\n");
1080         if (exit_on_error)
1081             ffmpeg_exit(1);
1082         return;
1083     }
1084
1085     enc = ost->st->codec;
1086
1087     if (!subtitle_out) {
1088         subtitle_out = av_malloc(subtitle_out_max_size);
1089     }
1090
1091     /* Note: DVB subtitle need one packet to draw them and one other
1092        packet to clear them */
1093     /* XXX: signal it in the codec context ? */
1094     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1095         nb = 2;
1096     else
1097         nb = 1;
1098
1099     for(i = 0; i < nb; i++) {
1100         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1101         // start_display_time is required to be 0
1102         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1103         sub->end_display_time -= sub->start_display_time;
1104         sub->start_display_time = 0;
1105         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1106                                                     subtitle_out_max_size, sub);
1107         if (subtitle_out_size < 0) {
1108             fprintf(stderr, "Subtitle encoding failed\n");
1109             ffmpeg_exit(1);
1110         }
1111
1112         av_init_packet(&pkt);
1113         pkt.stream_index = ost->index;
1114         pkt.data = subtitle_out;
1115         pkt.size = subtitle_out_size;
1116         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1117         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1118             /* XXX: the pts correction is handled here. Maybe handling
1119                it in the codec would be better */
1120             if (i == 0)
1121                 pkt.pts += 90 * sub->start_display_time;
1122             else
1123                 pkt.pts += 90 * sub->end_display_time;
1124         }
1125         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1126     }
1127 }
1128
1129 static int bit_buffer_size= 1024*256;
1130 static uint8_t *bit_buffer= NULL;
1131
1132 static void do_video_out(AVFormatContext *s,
1133                          AVOutputStream *ost,
1134                          AVInputStream *ist,
1135                          AVFrame *in_picture,
1136                          int *frame_size)
1137 {
1138     int nb_frames, i, ret;
1139     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1140     AVCodecContext *enc, *dec;
1141     double sync_ipts;
1142
1143     enc = ost->st->codec;
1144     dec = ist->st->codec;
1145
1146     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1147
1148     /* by default, we output a single frame */
1149     nb_frames = 1;
1150
1151     *frame_size = 0;
1152
1153     if(video_sync_method){
1154         double vdelta = sync_ipts - ost->sync_opts;
1155         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1156         if (vdelta < -1.1)
1157             nb_frames = 0;
1158         else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1159             if(vdelta<=-0.6){
1160                 nb_frames=0;
1161             }else if(vdelta>0.6)
1162                 ost->sync_opts= lrintf(sync_ipts);
1163         }else if (vdelta > 1.1)
1164             nb_frames = lrintf(vdelta);
1165 //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);
1166         if (nb_frames == 0){
1167             ++nb_frames_drop;
1168             if (verbose>2)
1169                 fprintf(stderr, "*** drop!\n");
1170         }else if (nb_frames > 1) {
1171             nb_frames_dup += nb_frames - 1;
1172             if (verbose>2)
1173                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1174         }
1175     }else
1176         ost->sync_opts= lrintf(sync_ipts);
1177
1178     nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1179     if (nb_frames <= 0)
1180         return;
1181
1182     formatted_picture = in_picture;
1183     final_picture = formatted_picture;
1184     padding_src = formatted_picture;
1185     resampling_dst = &ost->pict_tmp;
1186
1187     if (   ost->resample_height != ist->st->codec->height
1188         || ost->resample_width  != ist->st->codec->width
1189         || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1190
1191         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));
1192         if(!ost->video_resample)
1193             ffmpeg_exit(1);
1194     }
1195
1196 #if !CONFIG_AVFILTER
1197     if (ost->video_resample) {
1198         padding_src = NULL;
1199         final_picture = &ost->pict_tmp;
1200         if(  ost->resample_height != ist->st->codec->height
1201           || ost->resample_width  != ist->st->codec->width
1202           || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1203
1204             /* initialize a new scaler context */
1205             sws_freeContext(ost->img_resample_ctx);
1206             sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1207             ost->img_resample_ctx = sws_getContext(
1208                 ist->st->codec->width,
1209                 ist->st->codec->height,
1210                 ist->st->codec->pix_fmt,
1211                 ost->st->codec->width,
1212                 ost->st->codec->height,
1213                 ost->st->codec->pix_fmt,
1214                 sws_flags, NULL, NULL, NULL);
1215             if (ost->img_resample_ctx == NULL) {
1216                 fprintf(stderr, "Cannot get resampling context\n");
1217                 ffmpeg_exit(1);
1218             }
1219         }
1220         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1221               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1222     }
1223 #endif
1224
1225     /* duplicates frame if needed */
1226     for(i=0;i<nb_frames;i++) {
1227         AVPacket pkt;
1228         av_init_packet(&pkt);
1229         pkt.stream_index= ost->index;
1230
1231         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1232             /* raw pictures are written as AVPicture structure to
1233                avoid any copies. We support temorarily the older
1234                method. */
1235             AVFrame* old_frame = enc->coded_frame;
1236             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1237             pkt.data= (uint8_t *)final_picture;
1238             pkt.size=  sizeof(AVPicture);
1239             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1240             pkt.flags |= AV_PKT_FLAG_KEY;
1241
1242             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1243             enc->coded_frame = old_frame;
1244         } else {
1245             AVFrame big_picture;
1246
1247             big_picture= *final_picture;
1248             /* better than nothing: use input picture interlaced
1249                settings */
1250             big_picture.interlaced_frame = in_picture->interlaced_frame;
1251             if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1252                 if(top_field_first == -1)
1253                     big_picture.top_field_first = in_picture->top_field_first;
1254                 else
1255                     big_picture.top_field_first = top_field_first;
1256             }
1257
1258             /* handles sameq here. This is not correct because it may
1259                not be a global option */
1260             big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1261             if(!me_threshold)
1262                 big_picture.pict_type = 0;
1263 //            big_picture.pts = AV_NOPTS_VALUE;
1264             big_picture.pts= ost->sync_opts;
1265 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1266 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1267             if (ost->forced_kf_index < ost->forced_kf_count &&
1268                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1269                 big_picture.pict_type = FF_I_TYPE;
1270                 ost->forced_kf_index++;
1271             }
1272             ret = avcodec_encode_video(enc,
1273                                        bit_buffer, bit_buffer_size,
1274                                        &big_picture);
1275             if (ret < 0) {
1276                 fprintf(stderr, "Video encoding failed\n");
1277                 ffmpeg_exit(1);
1278             }
1279
1280             if(ret>0){
1281                 pkt.data= bit_buffer;
1282                 pkt.size= ret;
1283                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1284                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1285 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1286    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1287    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1288
1289                 if(enc->coded_frame->key_frame)
1290                     pkt.flags |= AV_PKT_FLAG_KEY;
1291                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1292                 *frame_size = ret;
1293                 video_size += ret;
1294                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1295                 //        enc->frame_number-1, ret, enc->pict_type);
1296                 /* if two pass, output log */
1297                 if (ost->logfile && enc->stats_out) {
1298                     fprintf(ost->logfile, "%s", enc->stats_out);
1299                 }
1300             }
1301         }
1302         ost->sync_opts++;
1303         ost->frame_number++;
1304     }
1305 }
1306
1307 static double psnr(double d){
1308     return -10.0*log(d)/log(10.0);
1309 }
1310
1311 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1312                            int frame_size)
1313 {
1314     AVCodecContext *enc;
1315     int frame_number;
1316     double ti1, bitrate, avg_bitrate;
1317
1318     /* this is executed just the first time do_video_stats is called */
1319     if (!vstats_file) {
1320         vstats_file = fopen(vstats_filename, "w");
1321         if (!vstats_file) {
1322             perror("fopen");
1323             ffmpeg_exit(1);
1324         }
1325     }
1326
1327     enc = ost->st->codec;
1328     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1329         frame_number = ost->frame_number;
1330         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1331         if (enc->flags&CODEC_FLAG_PSNR)
1332             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1333
1334         fprintf(vstats_file,"f_size= %6d ", frame_size);
1335         /* compute pts value */
1336         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1337         if (ti1 < 0.01)
1338             ti1 = 0.01;
1339
1340         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1341         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1342         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1343             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1344         fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1345     }
1346 }
1347
1348 static void print_report(AVFormatContext **output_files,
1349                          AVOutputStream **ost_table, int nb_ostreams,
1350                          int is_last_report)
1351 {
1352     char buf[1024];
1353     AVOutputStream *ost;
1354     AVFormatContext *oc;
1355     int64_t total_size;
1356     AVCodecContext *enc;
1357     int frame_number, vid, i;
1358     double bitrate, ti1, pts;
1359     static int64_t last_time = -1;
1360     static int qp_histogram[52];
1361
1362     if (!is_last_report) {
1363         int64_t cur_time;
1364         /* display the report every 0.5 seconds */
1365         cur_time = av_gettime();
1366         if (last_time == -1) {
1367             last_time = cur_time;
1368             return;
1369         }
1370         if ((cur_time - last_time) < 500000)
1371             return;
1372         last_time = cur_time;
1373     }
1374
1375
1376     oc = output_files[0];
1377
1378     total_size = avio_size(oc->pb);
1379     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1380         total_size= avio_tell(oc->pb);
1381
1382     buf[0] = '\0';
1383     ti1 = 1e10;
1384     vid = 0;
1385     for(i=0;i<nb_ostreams;i++) {
1386         float q= -1;
1387         ost = ost_table[i];
1388         enc = ost->st->codec;
1389         if(!ost->st->stream_copy && enc->coded_frame)
1390             q= enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1391         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1392             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1393         }
1394         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1395             float t = (av_gettime()-timer_start) / 1000000.0;
1396
1397             frame_number = ost->frame_number;
1398             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1399                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1400             if(is_last_report)
1401                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1402             if(qp_hist){
1403                 int j;
1404                 int qp= lrintf(q);
1405                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1406                     qp_histogram[qp]++;
1407                 for(j=0; j<32; j++)
1408                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1409             }
1410             if (enc->flags&CODEC_FLAG_PSNR){
1411                 int j;
1412                 double error, error_sum=0;
1413                 double scale, scale_sum=0;
1414                 char type[3]= {'Y','U','V'};
1415                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1416                 for(j=0; j<3; j++){
1417                     if(is_last_report){
1418                         error= enc->error[j];
1419                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1420                     }else{
1421                         error= enc->coded_frame->error[j];
1422                         scale= enc->width*enc->height*255.0*255.0;
1423                     }
1424                     if(j) scale/=4;
1425                     error_sum += error;
1426                     scale_sum += scale;
1427                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1428                 }
1429                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1430             }
1431             vid = 1;
1432         }
1433         /* compute min output value */
1434         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1435         if ((pts < ti1) && (pts > 0))
1436             ti1 = pts;
1437     }
1438     if (ti1 < 0.01)
1439         ti1 = 0.01;
1440
1441     if (verbose || is_last_report) {
1442         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1443
1444         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1445             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1446             (double)total_size / 1024, ti1, bitrate);
1447
1448         if (nb_frames_dup || nb_frames_drop)
1449           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1450                   nb_frames_dup, nb_frames_drop);
1451
1452         if (verbose >= 0)
1453             fprintf(stderr, "%s    \r", buf);
1454
1455         fflush(stderr);
1456     }
1457
1458     if (is_last_report && verbose >= 0){
1459         int64_t raw= audio_size + video_size + extra_size;
1460         fprintf(stderr, "\n");
1461         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1462                 video_size/1024.0,
1463                 audio_size/1024.0,
1464                 extra_size/1024.0,
1465                 100.0*(total_size - raw)/raw
1466         );
1467     }
1468 }
1469
1470 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1471 {
1472     int fill_char = 0x00;
1473     if (sample_fmt == AV_SAMPLE_FMT_U8)
1474         fill_char = 0x80;
1475     memset(buf, fill_char, size);
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                                     generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, 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     av_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         avio_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     frame_aspect_ratio_override = 1;
2908 }
2909
2910 static int opt_metadata(const char *opt, const char *arg)
2911 {
2912     char *mid= strchr(arg, '=');
2913
2914     if(!mid){
2915         fprintf(stderr, "Missing =\n");
2916         ffmpeg_exit(1);
2917     }
2918     *mid++= 0;
2919
2920     av_metadata_set2(&metadata, arg, mid, 0);
2921
2922     return 0;
2923 }
2924
2925 static void opt_qscale(const char *arg)
2926 {
2927     video_qscale = atof(arg);
2928     if (video_qscale <= 0 ||
2929         video_qscale > 255) {
2930         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2931         ffmpeg_exit(1);
2932     }
2933 }
2934
2935 static void opt_top_field_first(const char *arg)
2936 {
2937     top_field_first= atoi(arg);
2938 }
2939
2940 static int opt_thread_count(const char *opt, const char *arg)
2941 {
2942     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2943 #if !HAVE_THREADS
2944     if (verbose >= 0)
2945         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2946 #endif
2947     return 0;
2948 }
2949
2950 static void opt_audio_sample_fmt(const char *arg)
2951 {
2952     if (strcmp(arg, "list")) {
2953         audio_sample_fmt = av_get_sample_fmt(arg);
2954         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2955             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2956             ffmpeg_exit(1);
2957         }
2958     } else {
2959         int i;
2960         char fmt_str[128];
2961         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2962             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2963         ffmpeg_exit(0);
2964     }
2965 }
2966
2967 static int opt_audio_rate(const char *opt, const char *arg)
2968 {
2969     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2970     return 0;
2971 }
2972
2973 static int opt_audio_channels(const char *opt, const char *arg)
2974 {
2975     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2976     return 0;
2977 }
2978
2979 static void opt_video_channel(const char *arg)
2980 {
2981     video_channel = strtol(arg, NULL, 0);
2982 }
2983
2984 static void opt_video_standard(const char *arg)
2985 {
2986     video_standard = av_strdup(arg);
2987 }
2988
2989 static void opt_codec(int *pstream_copy, char **pcodec_name,
2990                       int codec_type, const char *arg)
2991 {
2992     av_freep(pcodec_name);
2993     if (!strcmp(arg, "copy")) {
2994         *pstream_copy = 1;
2995     } else {
2996         *pcodec_name = av_strdup(arg);
2997     }
2998 }
2999
3000 static void opt_audio_codec(const char *arg)
3001 {
3002     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3003 }
3004
3005 static void opt_video_codec(const char *arg)
3006 {
3007     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3008 }
3009
3010 static void opt_subtitle_codec(const char *arg)
3011 {
3012     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3013 }
3014
3015 static int opt_codec_tag(const char *opt, const char *arg)
3016 {
3017     char *tail;
3018     uint32_t *codec_tag;
3019
3020     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3021                 !strcmp(opt, "vtag") ? &video_codec_tag :
3022                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3023     if (!codec_tag)
3024         return -1;
3025
3026     *codec_tag = strtol(arg, &tail, 0);
3027     if (!tail || *tail)
3028         *codec_tag = AV_RL32(arg);
3029
3030     return 0;
3031 }
3032
3033 static void opt_map(const char *arg)
3034 {
3035     AVStreamMap *m;
3036     char *p;
3037
3038     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3039     m = &stream_maps[nb_stream_maps-1];
3040
3041     m->file_index = strtol(arg, &p, 0);
3042     if (*p)
3043         p++;
3044
3045     m->stream_index = strtol(p, &p, 0);
3046     if (*p) {
3047         p++;
3048         m->sync_file_index = strtol(p, &p, 0);
3049         if (*p)
3050             p++;
3051         m->sync_stream_index = strtol(p, &p, 0);
3052     } else {
3053         m->sync_file_index = m->file_index;
3054         m->sync_stream_index = m->stream_index;
3055     }
3056 }
3057
3058 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3059 {
3060     *endptr = arg;
3061     if (*arg == ',') {
3062         *type = *(++arg);
3063         switch (*arg) {
3064         case 'g':
3065             break;
3066         case 's':
3067         case 'c':
3068         case 'p':
3069             *index = strtol(++arg, endptr, 0);
3070             break;
3071         default:
3072             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3073             ffmpeg_exit(1);
3074         }
3075     } else
3076         *type = 'g';
3077 }
3078
3079 static void opt_map_metadata(const char *arg)
3080 {
3081     AVMetaDataMap *m, *m1;
3082     char *p;
3083
3084     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3085                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
3086
3087     m = &meta_data_maps[nb_meta_data_maps - 1][0];
3088     m->file = strtol(arg, &p, 0);
3089     parse_meta_type(p, &m->type, &m->index, &p);
3090     if (*p)
3091         p++;
3092
3093     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3094     m1->file = strtol(p, &p, 0);
3095     parse_meta_type(p, &m1->type, &m1->index, &p);
3096
3097     if (m->type == 'g' || m1->type == 'g')
3098         metadata_global_autocopy = 0;
3099     if (m->type == 's' || m1->type == 's')
3100         metadata_streams_autocopy = 0;
3101     if (m->type == 'c' || m1->type == 'c')
3102         metadata_chapters_autocopy = 0;
3103 }
3104
3105 static void opt_map_meta_data(const char *arg)
3106 {
3107     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3108                     "Use -map_metadata instead.\n");
3109     opt_map_metadata(arg);
3110 }
3111
3112 static void opt_map_chapters(const char *arg)
3113 {
3114     AVChapterMap *c;
3115     char *p;
3116
3117     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3118                               nb_chapter_maps + 1);
3119     c = &chapter_maps[nb_chapter_maps - 1];
3120     c->out_file = strtol(arg, &p, 0);
3121     if (*p)
3122         p++;
3123
3124     c->in_file = strtol(p, &p, 0);
3125 }
3126
3127 static void opt_input_ts_scale(const char *arg)
3128 {
3129     unsigned int stream;
3130     double scale;
3131     char *p;
3132
3133     stream = strtol(arg, &p, 0);
3134     if (*p)
3135         p++;
3136     scale= strtod(p, &p);
3137
3138     if(stream >= MAX_STREAMS)
3139         ffmpeg_exit(1);
3140
3141     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);
3142     input_files_ts_scale[nb_input_files][stream]= scale;
3143 }
3144
3145 static int opt_recording_time(const char *opt, const char *arg)
3146 {
3147     recording_time = parse_time_or_die(opt, arg, 1);
3148     return 0;
3149 }
3150
3151 static int opt_start_time(const char *opt, const char *arg)
3152 {
3153     start_time = parse_time_or_die(opt, arg, 1);
3154     return 0;
3155 }
3156
3157 static int opt_recording_timestamp(const char *opt, const char *arg)
3158 {
3159     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3160     return 0;
3161 }
3162
3163 static int opt_input_ts_offset(const char *opt, const char *arg)
3164 {
3165     input_ts_offset = parse_time_or_die(opt, arg, 1);
3166     return 0;
3167 }
3168
3169 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3170 {
3171     const char *codec_string = encoder ? "encoder" : "decoder";
3172     AVCodec *codec;
3173
3174     if(!name)
3175         return CODEC_ID_NONE;
3176     codec = encoder ?
3177         avcodec_find_encoder_by_name(name) :
3178         avcodec_find_decoder_by_name(name);
3179     if(!codec) {
3180         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3181         ffmpeg_exit(1);
3182     }
3183     if(codec->type != type) {
3184         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3185         ffmpeg_exit(1);
3186     }
3187     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3188        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3189         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3190                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3191                 codec_string, codec->name);
3192         codec = encoder ?
3193             avcodec_find_encoder(codec->id) :
3194             avcodec_find_decoder(codec->id);
3195         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3196             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3197                     codec_string, codec->name);
3198         ffmpeg_exit(1);
3199     }
3200     return codec->id;
3201 }
3202
3203 static void opt_input_file(const char *filename)
3204 {
3205     AVFormatContext *ic;
3206     AVFormatParameters params, *ap = &params;
3207     AVInputFormat *file_iformat = NULL;
3208     int err, i, ret, rfps, rfps_base;
3209     int64_t timestamp;
3210
3211     if (last_asked_format) {
3212         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3213             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3214             ffmpeg_exit(1);
3215         }
3216         last_asked_format = NULL;
3217     }
3218
3219     if (!strcmp(filename, "-"))
3220         filename = "pipe:";
3221
3222     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3223                     !strcmp(filename, "/dev/stdin");
3224
3225     /* get default parameters from command line */
3226     ic = avformat_alloc_context();
3227     if (!ic) {
3228         print_error(filename, AVERROR(ENOMEM));
3229         ffmpeg_exit(1);
3230     }
3231
3232     memset(ap, 0, sizeof(*ap));
3233     ap->prealloced_context = 1;
3234     ap->sample_rate = audio_sample_rate;
3235     ap->channels = audio_channels;
3236     ap->time_base.den = frame_rate.num;
3237     ap->time_base.num = frame_rate.den;
3238     ap->width = frame_width;
3239     ap->height = frame_height;
3240     ap->pix_fmt = frame_pix_fmt;
3241    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3242     ap->channel = video_channel;
3243     ap->standard = video_standard;
3244
3245     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3246
3247     ic->video_codec_id   =
3248         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3249                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3250     ic->audio_codec_id   =
3251         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3252                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3253     ic->subtitle_codec_id=
3254         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3255                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3256     ic->flags |= AVFMT_FLAG_NONBLOCK;
3257
3258     /* open the input file with generic libav function */
3259     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3260     if (err < 0) {
3261         print_error(filename, err);
3262         ffmpeg_exit(1);
3263     }
3264     if(opt_programid) {
3265         int i, j;
3266         int found=0;
3267         for(i=0; i<ic->nb_streams; i++){
3268             ic->streams[i]->discard= AVDISCARD_ALL;
3269         }
3270         for(i=0; i<ic->nb_programs; i++){
3271             AVProgram *p= ic->programs[i];
3272             if(p->id != opt_programid){
3273                 p->discard = AVDISCARD_ALL;
3274             }else{
3275                 found=1;
3276                 for(j=0; j<p->nb_stream_indexes; j++){
3277                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3278                 }
3279             }
3280         }
3281         if(!found){
3282             fprintf(stderr, "Specified program id not found\n");
3283             ffmpeg_exit(1);
3284         }
3285         opt_programid=0;
3286     }
3287
3288     ic->loop_input = loop_input;
3289
3290     /* If not enough info to get the stream parameters, we decode the
3291        first frames to get it. (used in mpeg case for example) */
3292     ret = av_find_stream_info(ic);
3293     if (ret < 0 && verbose >= 0) {
3294         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3295         av_close_input_file(ic);
3296         ffmpeg_exit(1);
3297     }
3298
3299     timestamp = start_time;
3300     /* add the stream start time */
3301     if (ic->start_time != AV_NOPTS_VALUE)
3302         timestamp += ic->start_time;
3303
3304     /* if seeking requested, we execute it */
3305     if (start_time != 0) {
3306         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3307         if (ret < 0) {
3308             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3309                     filename, (double)timestamp / AV_TIME_BASE);
3310         }
3311         /* reset seek info */
3312         start_time = 0;
3313     }
3314
3315     /* update the current parameters so that they match the one of the input stream */
3316     for(i=0;i<ic->nb_streams;i++) {
3317         AVStream *st = ic->streams[i];
3318         AVCodecContext *dec = st->codec;
3319         dec->thread_count = thread_count;
3320         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3321         switch (dec->codec_type) {
3322         case AVMEDIA_TYPE_AUDIO:
3323             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3324             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]);
3325             //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3326             channel_layout    = dec->channel_layout;
3327             audio_channels    = dec->channels;
3328             audio_sample_rate = dec->sample_rate;
3329             audio_sample_fmt  = dec->sample_fmt;
3330             if(audio_disable)
3331                 st->discard= AVDISCARD_ALL;
3332             /* Note that av_find_stream_info can add more streams, and we
3333              * currently have no chance of setting up lowres decoding
3334              * early enough for them. */
3335             if (dec->lowres)
3336                 audio_sample_rate >>= dec->lowres;
3337             break;
3338         case AVMEDIA_TYPE_VIDEO:
3339             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3340             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]);
3341             frame_height = dec->height;
3342             frame_width  = dec->width;
3343             if(ic->streams[i]->sample_aspect_ratio.num)
3344                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3345             else
3346                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3347             frame_aspect_ratio *= (float) dec->width / dec->height;
3348             frame_aspect_ratio_override = 0;
3349             frame_pix_fmt = dec->pix_fmt;
3350             rfps      = ic->streams[i]->r_frame_rate.num;
3351             rfps_base = ic->streams[i]->r_frame_rate.den;
3352             if (dec->lowres) {
3353                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3354                 frame_height >>= dec->lowres;
3355                 frame_width  >>= dec->lowres;
3356                 dec->height = frame_height;
3357                 dec->width  = frame_width;
3358             }
3359             if(me_threshold)
3360                 dec->debug |= FF_DEBUG_MV;
3361
3362             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3363
3364                 if (verbose >= 0)
3365                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3366                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3367
3368                     (float)rfps / rfps_base, rfps, rfps_base);
3369             }
3370             /* update the current frame rate to match the stream frame rate */
3371             frame_rate.num = rfps;
3372             frame_rate.den = rfps_base;
3373
3374             if(video_disable)
3375                 st->discard= AVDISCARD_ALL;
3376             else if(video_discard)
3377                 st->discard= video_discard;
3378             break;
3379         case AVMEDIA_TYPE_DATA:
3380             break;
3381         case AVMEDIA_TYPE_SUBTITLE:
3382             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3383             if(subtitle_disable)
3384                 st->discard = AVDISCARD_ALL;
3385             break;
3386         case AVMEDIA_TYPE_ATTACHMENT:
3387         case AVMEDIA_TYPE_UNKNOWN:
3388             break;
3389         default:
3390             abort();
3391         }
3392     }
3393
3394     input_files[nb_input_files] = ic;
3395     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3396     /* dump the file content */
3397     if (verbose >= 0)
3398         av_dump_format(ic, nb_input_files, filename, 0);
3399
3400     nb_input_files++;
3401
3402     video_channel = 0;
3403
3404     av_freep(&video_codec_name);
3405     av_freep(&audio_codec_name);
3406     av_freep(&subtitle_codec_name);
3407 }
3408
3409 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3410                                          int *has_subtitle_ptr)
3411 {
3412     int has_video, has_audio, has_subtitle, i, j;
3413     AVFormatContext *ic;
3414
3415     has_video = 0;
3416     has_audio = 0;
3417     has_subtitle = 0;
3418     for(j=0;j<nb_input_files;j++) {
3419         ic = input_files[j];
3420         for(i=0;i<ic->nb_streams;i++) {
3421             AVCodecContext *enc = ic->streams[i]->codec;
3422             switch(enc->codec_type) {
3423             case AVMEDIA_TYPE_AUDIO:
3424                 has_audio = 1;
3425                 break;
3426             case AVMEDIA_TYPE_VIDEO:
3427                 has_video = 1;
3428                 break;
3429             case AVMEDIA_TYPE_SUBTITLE:
3430                 has_subtitle = 1;
3431                 break;
3432             case AVMEDIA_TYPE_DATA:
3433             case AVMEDIA_TYPE_ATTACHMENT:
3434             case AVMEDIA_TYPE_UNKNOWN:
3435                 break;
3436             default:
3437                 abort();
3438             }
3439         }
3440     }
3441     *has_video_ptr = has_video;
3442     *has_audio_ptr = has_audio;
3443     *has_subtitle_ptr = has_subtitle;
3444 }
3445
3446 static void new_video_stream(AVFormatContext *oc, int file_idx)
3447 {
3448     AVStream *st;
3449     AVOutputStream *ost;
3450     AVCodecContext *video_enc;
3451     enum CodecID codec_id = CODEC_ID_NONE;
3452     AVCodec *codec= NULL;
3453     int i;
3454
3455     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3456     if (!st) {
3457         fprintf(stderr, "Could not alloc stream\n");
3458         ffmpeg_exit(1);
3459     }
3460     ost = new_output_stream(oc, file_idx);
3461
3462     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3463     if(!video_stream_copy){
3464         if (video_codec_name) {
3465             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3466                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3467             codec = avcodec_find_encoder_by_name(video_codec_name);
3468             output_codecs[nb_output_codecs-1] = codec;
3469         } else {
3470             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3471             codec = avcodec_find_encoder(codec_id);
3472         }
3473 #if CONFIG_AVFILTER
3474         if(frame_aspect_ratio_override){
3475             i = vfilters ? strlen(vfilters) : 0;
3476             vfilters = av_realloc(vfilters, i+100);
3477             snprintf(vfilters+i, 100, "%csetdar=%f\n", i?',':' ', frame_aspect_ratio);
3478             frame_aspect_ratio=0;
3479             frame_aspect_ratio_override=0;
3480         }
3481
3482         ost->avfilter= vfilters;
3483         vfilters= NULL;
3484 #endif
3485     }
3486
3487     avcodec_get_context_defaults3(st->codec, codec);
3488     ost->bitstream_filters = video_bitstream_filters;
3489     video_bitstream_filters= NULL;
3490
3491     st->codec->thread_count= thread_count;
3492
3493     video_enc = st->codec;
3494
3495     if(video_codec_tag)
3496         video_enc->codec_tag= video_codec_tag;
3497
3498     if(   (video_global_header&1)
3499        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3500         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3501         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3502     }
3503     if(video_global_header&2){
3504         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3505         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3506     }
3507
3508     if (video_stream_copy) {
3509         st->stream_copy = 1;
3510         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3511         video_enc->sample_aspect_ratio =
3512         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3513     } else {
3514         const char *p;
3515         int i;
3516         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3517
3518         video_enc->codec_id = codec_id;
3519         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3520
3521         if (codec && codec->supported_framerates && !force_fps)
3522             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3523         video_enc->time_base.den = fps.num;
3524         video_enc->time_base.num = fps.den;
3525
3526         video_enc->width = frame_width;
3527         video_enc->height = frame_height;
3528         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3529         video_enc->pix_fmt = frame_pix_fmt;
3530         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3531         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3532
3533         choose_pixel_fmt(st, codec);
3534
3535         if (intra_only)
3536             video_enc->gop_size = 0;
3537         if (video_qscale || same_quality) {
3538             video_enc->flags |= CODEC_FLAG_QSCALE;
3539             video_enc->global_quality=
3540                 st->quality = FF_QP2LAMBDA * video_qscale;
3541         }
3542
3543         if(intra_matrix)
3544             video_enc->intra_matrix = intra_matrix;
3545         if(inter_matrix)
3546             video_enc->inter_matrix = inter_matrix;
3547
3548         p= video_rc_override_string;
3549         for(i=0; p; i++){
3550             int start, end, q;
3551             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3552             if(e!=3){
3553                 fprintf(stderr, "error parsing rc_override\n");
3554                 ffmpeg_exit(1);
3555             }
3556             video_enc->rc_override=
3557                 av_realloc(video_enc->rc_override,
3558                            sizeof(RcOverride)*(i+1));
3559             video_enc->rc_override[i].start_frame= start;
3560             video_enc->rc_override[i].end_frame  = end;
3561             if(q>0){
3562                 video_enc->rc_override[i].qscale= q;
3563                 video_enc->rc_override[i].quality_factor= 1.0;
3564             }
3565             else{
3566                 video_enc->rc_override[i].qscale= 0;
3567                 video_enc->rc_override[i].quality_factor= -q/100.0;
3568             }
3569             p= strchr(p, '/');
3570             if(p) p++;
3571         }
3572         video_enc->rc_override_count=i;
3573         if (!video_enc->rc_initial_buffer_occupancy)
3574             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3575         video_enc->me_threshold= me_threshold;
3576         video_enc->intra_dc_precision= intra_dc_precision - 8;
3577
3578         if (do_psnr)
3579             video_enc->flags|= CODEC_FLAG_PSNR;
3580
3581         /* two pass mode */
3582         if (do_pass) {
3583             if (do_pass == 1) {
3584                 video_enc->flags |= CODEC_FLAG_PASS1;
3585             } else {
3586                 video_enc->flags |= CODEC_FLAG_PASS2;
3587             }
3588         }
3589
3590         if (forced_key_frames)
3591             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3592     }
3593     if (video_language) {
3594         av_metadata_set2(&st->metadata, "language", video_language, 0);
3595         av_freep(&video_language);
3596     }
3597
3598     /* reset some key parameters */
3599     video_disable = 0;
3600     av_freep(&video_codec_name);
3601     av_freep(&forced_key_frames);
3602     video_stream_copy = 0;
3603     frame_pix_fmt = PIX_FMT_NONE;
3604 }
3605
3606 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3607 {
3608     AVStream *st;
3609     AVOutputStream *ost;
3610     AVCodec *codec= NULL;
3611     AVCodecContext *audio_enc;
3612     enum CodecID codec_id = CODEC_ID_NONE;
3613
3614     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3615     if (!st) {
3616         fprintf(stderr, "Could not alloc stream\n");
3617         ffmpeg_exit(1);
3618     }
3619     ost = new_output_stream(oc, file_idx);
3620
3621     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3622     if(!audio_stream_copy){
3623         if (audio_codec_name) {
3624             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3625                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3626             codec = avcodec_find_encoder_by_name(audio_codec_name);
3627             output_codecs[nb_output_codecs-1] = codec;
3628         } else {
3629             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3630             codec = avcodec_find_encoder(codec_id);
3631         }
3632     }
3633
3634     avcodec_get_context_defaults3(st->codec, codec);
3635
3636     ost->bitstream_filters = audio_bitstream_filters;
3637     audio_bitstream_filters= NULL;
3638
3639     st->codec->thread_count= thread_count;
3640
3641     audio_enc = st->codec;
3642     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3643
3644     if(audio_codec_tag)
3645         audio_enc->codec_tag= audio_codec_tag;
3646
3647     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3648         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3649         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3650     }
3651     if (audio_stream_copy) {
3652         st->stream_copy = 1;
3653         audio_enc->channels = audio_channels;
3654         audio_enc->sample_rate = audio_sample_rate;
3655     } else {
3656         audio_enc->codec_id = codec_id;
3657         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3658
3659         if (audio_qscale > QSCALE_NONE) {
3660             audio_enc->flags |= CODEC_FLAG_QSCALE;
3661             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3662         }
3663         audio_enc->channels = audio_channels;
3664         audio_enc->sample_fmt = audio_sample_fmt;
3665         audio_enc->sample_rate = audio_sample_rate;
3666         audio_enc->channel_layout = channel_layout;
3667         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3668             audio_enc->channel_layout = 0;
3669         choose_sample_fmt(st, codec);
3670         choose_sample_rate(st, codec);
3671     }
3672     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3673     if (audio_language) {
3674         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3675         av_freep(&audio_language);
3676     }
3677
3678     /* reset some key parameters */
3679     audio_disable = 0;
3680     av_freep(&audio_codec_name);
3681     audio_stream_copy = 0;
3682 }
3683
3684 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3685 {
3686     AVStream *st;
3687     AVOutputStream *ost;
3688     AVCodec *codec=NULL;
3689     AVCodecContext *subtitle_enc;
3690     enum CodecID codec_id = CODEC_ID_NONE;
3691
3692     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3693     if (!st) {
3694         fprintf(stderr, "Could not alloc stream\n");
3695         ffmpeg_exit(1);
3696     }
3697     ost = new_output_stream(oc, file_idx);
3698     subtitle_enc = st->codec;
3699     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3700     if(!subtitle_stream_copy){
3701         if (subtitle_codec_name) {
3702             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3703                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3704             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3705         } else {
3706             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3707             codec = avcodec_find_encoder(codec_id);
3708         }
3709     }
3710     avcodec_get_context_defaults3(st->codec, codec);
3711
3712     ost->bitstream_filters = subtitle_bitstream_filters;
3713     subtitle_bitstream_filters= NULL;
3714
3715     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3716
3717     if(subtitle_codec_tag)
3718         subtitle_enc->codec_tag= subtitle_codec_tag;
3719
3720     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3721         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3722         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3723     }
3724     if (subtitle_stream_copy) {
3725         st->stream_copy = 1;
3726     } else {
3727         subtitle_enc->codec_id = codec_id;
3728         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3729     }
3730
3731     if (subtitle_language) {
3732         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3733         av_freep(&subtitle_language);
3734     }
3735
3736     subtitle_disable = 0;
3737     av_freep(&subtitle_codec_name);
3738     subtitle_stream_copy = 0;
3739 }
3740
3741 static int opt_new_stream(const char *opt, const char *arg)
3742 {
3743     AVFormatContext *oc;
3744     int file_idx = nb_output_files - 1;
3745     if (nb_output_files <= 0) {
3746         fprintf(stderr, "At least one output file must be specified\n");
3747         ffmpeg_exit(1);
3748     }
3749     oc = output_files[file_idx];
3750
3751     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3752     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3753     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3754     else av_assert0(0);
3755     return 0;
3756 }
3757
3758 /* arg format is "output-stream-index:streamid-value". */
3759 static int opt_streamid(const char *opt, const char *arg)
3760 {
3761     int idx;
3762     char *p;
3763     char idx_str[16];
3764
3765     strncpy(idx_str, arg, sizeof(idx_str));
3766     idx_str[sizeof(idx_str)-1] = '\0';
3767     p = strchr(idx_str, ':');
3768     if (!p) {
3769         fprintf(stderr,
3770                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3771                 arg, opt);
3772         ffmpeg_exit(1);
3773     }
3774     *p++ = '\0';
3775     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3776     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3777     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3778     return 0;
3779 }
3780
3781 static void opt_output_file(const char *filename)
3782 {
3783     AVFormatContext *oc;
3784     int err, use_video, use_audio, use_subtitle;
3785     int input_has_video, input_has_audio, input_has_subtitle;
3786     AVFormatParameters params, *ap = &params;
3787     AVOutputFormat *file_oformat;
3788
3789     if (!strcmp(filename, "-"))
3790         filename = "pipe:";
3791
3792     oc = avformat_alloc_context();
3793     if (!oc) {
3794         print_error(filename, AVERROR(ENOMEM));
3795         ffmpeg_exit(1);
3796     }
3797
3798     if (last_asked_format) {
3799         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3800         if (!file_oformat) {
3801             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3802             ffmpeg_exit(1);
3803         }
3804         last_asked_format = NULL;
3805     } else {
3806         file_oformat = av_guess_format(NULL, filename, NULL);
3807         if (!file_oformat) {
3808             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3809                     filename);
3810             ffmpeg_exit(1);
3811         }
3812     }
3813
3814     oc->oformat = file_oformat;
3815     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3816
3817     if (!strcmp(file_oformat->name, "ffm") &&
3818         av_strstart(filename, "http:", NULL)) {
3819         /* special case for files sent to ffserver: we get the stream
3820            parameters from ffserver */
3821         int err = read_ffserver_streams(oc, filename);
3822         if (err < 0) {
3823             print_error(filename, err);
3824             ffmpeg_exit(1);
3825         }
3826     } else {
3827         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3828         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3829         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3830
3831         /* disable if no corresponding type found and at least one
3832            input file */
3833         if (nb_input_files > 0) {
3834             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3835                                          &input_has_subtitle);
3836             if (!input_has_video)
3837                 use_video = 0;
3838             if (!input_has_audio)
3839                 use_audio = 0;
3840             if (!input_has_subtitle)
3841                 use_subtitle = 0;
3842         }
3843
3844         /* manual disable */
3845         if (audio_disable)    use_audio    = 0;
3846         if (video_disable)    use_video    = 0;
3847         if (subtitle_disable) use_subtitle = 0;
3848
3849         if (use_video)    new_video_stream(oc, nb_output_files);
3850         if (use_audio)    new_audio_stream(oc, nb_output_files);
3851         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3852
3853         oc->timestamp = recording_timestamp;
3854
3855         av_metadata_copy(&oc->metadata, metadata, 0);
3856         av_metadata_free(&metadata);
3857     }
3858
3859     output_files[nb_output_files++] = oc;
3860
3861     /* check filename in case of an image number is expected */
3862     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3863         if (!av_filename_number_test(oc->filename)) {
3864             print_error(oc->filename, AVERROR_NUMEXPECTED);
3865             ffmpeg_exit(1);
3866         }
3867     }
3868
3869     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3870         /* test if it already exists to avoid loosing precious files */
3871         if (!file_overwrite &&
3872             (strchr(filename, ':') == NULL ||
3873              filename[1] == ':' ||
3874              av_strstart(filename, "file:", NULL))) {
3875             if (url_exist(filename)) {
3876                 if (!using_stdin) {
3877                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3878                     fflush(stderr);
3879                     if (!read_yesno()) {
3880                         fprintf(stderr, "Not overwriting - exiting\n");
3881                         ffmpeg_exit(1);
3882                     }
3883                 }
3884                 else {
3885                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3886                     ffmpeg_exit(1);
3887                 }
3888             }
3889         }
3890
3891         /* open the file */
3892         if ((err = avio_open(&oc->pb, filename, AVIO_WRONLY)) < 0) {
3893             print_error(filename, err);
3894             ffmpeg_exit(1);
3895         }
3896     }
3897
3898     memset(ap, 0, sizeof(*ap));
3899     if (av_set_parameters(oc, ap) < 0) {
3900         fprintf(stderr, "%s: Invalid encoding parameters\n",
3901                 oc->filename);
3902         ffmpeg_exit(1);
3903     }
3904
3905     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3906     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3907     oc->loop_output = loop_output;
3908
3909     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3910
3911     av_freep(&forced_key_frames);
3912 }
3913
3914 /* same option as mencoder */
3915 static void opt_pass(const char *pass_str)
3916 {
3917     int pass;
3918     pass = atoi(pass_str);
3919     if (pass != 1 && pass != 2) {
3920         fprintf(stderr, "pass number can be only 1 or 2\n");
3921         ffmpeg_exit(1);
3922     }
3923     do_pass = pass;
3924 }
3925
3926 static int64_t getutime(void)
3927 {
3928 #if HAVE_GETRUSAGE
3929     struct rusage rusage;
3930
3931     getrusage(RUSAGE_SELF, &rusage);
3932     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3933 #elif HAVE_GETPROCESSTIMES
3934     HANDLE proc;
3935     FILETIME c, e, k, u;
3936     proc = GetCurrentProcess();
3937     GetProcessTimes(proc, &c, &e, &k, &u);
3938     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3939 #else
3940     return av_gettime();
3941 #endif
3942 }
3943
3944 static int64_t getmaxrss(void)
3945 {
3946 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3947     struct rusage rusage;
3948     getrusage(RUSAGE_SELF, &rusage);
3949     return (int64_t)rusage.ru_maxrss * 1024;
3950 #elif HAVE_GETPROCESSMEMORYINFO
3951     HANDLE proc;
3952     PROCESS_MEMORY_COUNTERS memcounters;
3953     proc = GetCurrentProcess();
3954     memcounters.cb = sizeof(memcounters);
3955     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3956     return memcounters.PeakPagefileUsage;
3957 #else
3958     return 0;
3959 #endif
3960 }
3961
3962 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3963 {
3964     int i;
3965     const char *p = str;
3966     for(i = 0;; i++) {
3967         dest[i] = atoi(p);
3968         if(i == 63)
3969             break;
3970         p = strchr(p, ',');
3971         if(!p) {
3972             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3973             ffmpeg_exit(1);
3974         }
3975         p++;
3976     }
3977 }
3978
3979 static void opt_inter_matrix(const char *arg)
3980 {
3981     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3982     parse_matrix_coeffs(inter_matrix, arg);
3983 }
3984
3985 static void opt_intra_matrix(const char *arg)
3986 {
3987     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3988     parse_matrix_coeffs(intra_matrix, arg);
3989 }
3990
3991 static void show_usage(void)
3992 {
3993     printf("Hyper fast Audio and Video encoder\n");
3994     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3995     printf("\n");
3996 }
3997
3998 static void show_help(void)
3999 {
4000     AVCodec *c;
4001     AVOutputFormat *oformat = NULL;
4002
4003     av_log_set_callback(log_callback_help);
4004     show_usage();
4005     show_help_options(options, "Main options:\n",
4006                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4007     show_help_options(options, "\nAdvanced options:\n",
4008                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4009                       OPT_EXPERT);
4010     show_help_options(options, "\nVideo options:\n",
4011                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4012                       OPT_VIDEO);
4013     show_help_options(options, "\nAdvanced Video options:\n",
4014                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4015                       OPT_VIDEO | OPT_EXPERT);
4016     show_help_options(options, "\nAudio options:\n",
4017                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4018                       OPT_AUDIO);
4019     show_help_options(options, "\nAdvanced Audio options:\n",
4020                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4021                       OPT_AUDIO | OPT_EXPERT);
4022     show_help_options(options, "\nSubtitle options:\n",
4023                       OPT_SUBTITLE | OPT_GRAB,
4024                       OPT_SUBTITLE);
4025     show_help_options(options, "\nAudio/Video grab options:\n",
4026                       OPT_GRAB,
4027                       OPT_GRAB);
4028     printf("\n");
4029     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4030     printf("\n");
4031
4032     /* individual codec options */
4033     c = NULL;
4034     while ((c = av_codec_next(c))) {
4035         if (c->priv_class) {
4036             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4037             printf("\n");
4038         }
4039     }
4040
4041     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4042     printf("\n");
4043
4044     /* individual muxer options */
4045     while ((oformat = av_oformat_next(oformat))) {
4046         if (oformat->priv_class) {
4047             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4048             printf("\n");
4049         }
4050     }
4051
4052     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4053 }
4054
4055 static void opt_target(const char *arg)
4056 {
4057     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4058     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4059
4060     if(!strncmp(arg, "pal-", 4)) {
4061         norm = PAL;
4062         arg += 4;
4063     } else if(!strncmp(arg, "ntsc-", 5)) {
4064         norm = NTSC;
4065         arg += 5;
4066     } else if(!strncmp(arg, "film-", 5)) {
4067         norm = FILM;
4068         arg += 5;
4069     } else {
4070         int fr;
4071         /* Calculate FR via float to avoid int overflow */
4072         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4073         if(fr == 25000) {
4074             norm = PAL;
4075         } else if((fr == 29970) || (fr == 23976)) {
4076             norm = NTSC;
4077         } else {
4078             /* Try to determine PAL/NTSC by peeking in the input files */
4079             if(nb_input_files) {
4080                 int i, j;
4081                 for(j = 0; j < nb_input_files; j++) {
4082                     for(i = 0; i < input_files[j]->nb_streams; i++) {
4083                         AVCodecContext *c = input_files[j]->streams[i]->codec;
4084                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4085                             continue;
4086                         fr = c->time_base.den * 1000 / c->time_base.num;
4087                         if(fr == 25000) {
4088                             norm = PAL;
4089                             break;
4090                         } else if((fr == 29970) || (fr == 23976)) {
4091                             norm = NTSC;
4092                             break;
4093                         }
4094                     }
4095                     if(norm != UNKNOWN)
4096                         break;
4097                 }
4098             }
4099         }
4100         if(verbose && norm != UNKNOWN)
4101             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4102     }
4103
4104     if(norm == UNKNOWN) {
4105         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4106         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4107         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4108         ffmpeg_exit(1);
4109     }
4110
4111     if(!strcmp(arg, "vcd")) {
4112
4113         opt_video_codec("mpeg1video");
4114         opt_audio_codec("mp2");
4115         opt_format("vcd");
4116
4117         opt_frame_size(norm == PAL ? "352x288" : "352x240");
4118         opt_frame_rate(NULL, frame_rates[norm]);
4119         opt_default("g", norm == PAL ? "15" : "18");
4120
4121         opt_default("b", "1150000");
4122         opt_default("maxrate", "1150000");
4123         opt_default("minrate", "1150000");
4124         opt_default("bufsize", "327680"); // 40*1024*8;
4125
4126         opt_default("ab", "224000");
4127         audio_sample_rate = 44100;
4128         audio_channels = 2;
4129
4130         opt_default("packetsize", "2324");
4131         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4132
4133         /* We have to offset the PTS, so that it is consistent with the SCR.
4134            SCR starts at 36000, but the first two packs contain only padding
4135            and the first pack from the other stream, respectively, may also have
4136            been written before.
4137            So the real data starts at SCR 36000+3*1200. */
4138         mux_preload= (36000+3*1200) / 90000.0; //0.44
4139     } else if(!strcmp(arg, "svcd")) {
4140
4141         opt_video_codec("mpeg2video");
4142         opt_audio_codec("mp2");
4143         opt_format("svcd");
4144
4145         opt_frame_size(norm == PAL ? "480x576" : "480x480");
4146         opt_frame_rate(NULL, frame_rates[norm]);
4147         opt_default("g", norm == PAL ? "15" : "18");
4148
4149         opt_default("b", "2040000");
4150         opt_default("maxrate", "2516000");
4151         opt_default("minrate", "0"); //1145000;
4152         opt_default("bufsize", "1835008"); //224*1024*8;
4153         opt_default("flags", "+scan_offset");
4154
4155
4156         opt_default("ab", "224000");
4157         audio_sample_rate = 44100;
4158
4159         opt_default("packetsize", "2324");
4160
4161     } else if(!strcmp(arg, "dvd")) {
4162
4163         opt_video_codec("mpeg2video");
4164         opt_audio_codec("ac3");
4165         opt_format("dvd");
4166
4167         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4168         opt_frame_rate(NULL, frame_rates[norm]);
4169         opt_default("g", norm == PAL ? "15" : "18");
4170
4171         opt_default("b", "6000000");
4172         opt_default("maxrate", "9000000");
4173         opt_default("minrate", "0"); //1500000;
4174         opt_default("bufsize", "1835008"); //224*1024*8;
4175
4176         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4177         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4178
4179         opt_default("ab", "448000");
4180         audio_sample_rate = 48000;
4181
4182     } else if(!strncmp(arg, "dv", 2)) {
4183
4184         opt_format("dv");
4185
4186         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4187         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4188                           (norm == PAL ? "yuv420p" : "yuv411p"));
4189         opt_frame_rate(NULL, frame_rates[norm]);
4190
4191         audio_sample_rate = 48000;
4192         audio_channels = 2;
4193
4194     } else {
4195         fprintf(stderr, "Unknown target: %s\n", arg);
4196         ffmpeg_exit(1);
4197     }
4198 }
4199
4200 static void opt_vstats_file (const char *arg)
4201 {
4202     av_free (vstats_filename);
4203     vstats_filename=av_strdup (arg);
4204 }
4205
4206 static void opt_vstats (void)
4207 {
4208     char filename[40];
4209     time_t today2 = time(NULL);
4210     struct tm *today = localtime(&today2);
4211
4212     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4213              today->tm_sec);
4214     opt_vstats_file(filename);
4215 }
4216
4217 static int opt_bsf(const char *opt, const char *arg)
4218 {
4219     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4220     AVBitStreamFilterContext **bsfp;
4221
4222     if(!bsfc){
4223         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4224         ffmpeg_exit(1);
4225     }
4226
4227     bsfp= *opt == 'v' ? &video_bitstream_filters :
4228           *opt == 'a' ? &audio_bitstream_filters :
4229                         &subtitle_bitstream_filters;
4230     while(*bsfp)
4231         bsfp= &(*bsfp)->next;
4232
4233     *bsfp= bsfc;
4234
4235     return 0;
4236 }
4237
4238 static int opt_preset(const char *opt, const char *arg)
4239 {
4240     FILE *f=NULL;
4241     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4242     char *codec_name = *opt == 'v' ? video_codec_name :
4243                        *opt == 'a' ? audio_codec_name :
4244                                      subtitle_codec_name;
4245
4246     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4247         fprintf(stderr, "File for preset '%s' not found\n", arg);
4248         ffmpeg_exit(1);
4249     }
4250
4251     while(!feof(f)){
4252         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4253         if(line[0] == '#' && !e)
4254             continue;
4255         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4256         if(e){
4257             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4258             ffmpeg_exit(1);
4259         }
4260         if(!strcmp(tmp, "acodec")){
4261             opt_audio_codec(tmp2);
4262         }else if(!strcmp(tmp, "vcodec")){
4263             opt_video_codec(tmp2);
4264         }else if(!strcmp(tmp, "scodec")){
4265             opt_subtitle_codec(tmp2);
4266         }else if(opt_default(tmp, tmp2) < 0){
4267             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4268             ffmpeg_exit(1);
4269         }
4270     }
4271
4272     fclose(f);
4273
4274     return 0;
4275 }
4276
4277 static const OptionDef options[] = {
4278     /* main options */
4279 #include "cmdutils_common_opts.h"
4280     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4281     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4282     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4283     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4284     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4285       "outfile[,metadata]:infile[,metadata]" },
4286     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4287       "outfile[,metadata]:infile[,metadata]" },
4288     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4289     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4290     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4291     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4292     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4293     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4294     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4295     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4296     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4297     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4298       "add timings for benchmarking" },
4299     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4300     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4301       "dump each input packet" },
4302     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4303       "when dumping packets, also dump the payload" },
4304     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4305     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4306     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4307     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4308     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4309     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4310     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4311     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4312     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4313     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4314     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4315     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4316     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4317     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4318     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4319     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4320     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4321
4322     /* video options */
4323     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4324     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4325     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4326     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4327     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4328     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4329     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4330     { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4331     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4332     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4333     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4334     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4335     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4336     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4337     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4338     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4339     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4340     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4341     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4342     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4343     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4344     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4345     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4346     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4347     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4348       "use same quantizer as source (implies VBR)" },
4349     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4350     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4351     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4352       "deinterlace pictures" },
4353     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4354     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4355     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4356 #if CONFIG_AVFILTER
4357     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4358 #endif
4359     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4360     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4361     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4362     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4363     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4364     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4365     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4366     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4367     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4368     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4369     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4370
4371     /* audio options */
4372     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4373     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4374     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4375     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4376     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4377     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4378     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4379     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4380     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4381     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4382     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4383     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4384
4385     /* subtitle options */
4386     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4387     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4388     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4389     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4390     { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4391
4392     /* grab options */
4393     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4394     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4395     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4396
4397     /* muxer options */
4398     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4399     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4400
4401     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4402     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4403     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4404
4405     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4406     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4407     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4408     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4409
4410     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4411     { NULL, },
4412 };
4413
4414 int main(int argc, char **argv)
4415 {
4416     int64_t ti;
4417
4418     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4419
4420     avcodec_register_all();
4421 #if CONFIG_AVDEVICE
4422     avdevice_register_all();
4423 #endif
4424 #if CONFIG_AVFILTER
4425     avfilter_register_all();
4426 #endif
4427     av_register_all();
4428
4429 #if HAVE_ISATTY
4430     if(isatty(STDIN_FILENO))
4431         avio_set_interrupt_cb(decode_interrupt_cb);
4432 #endif
4433
4434     init_opts();
4435
4436     show_banner();
4437
4438     /* parse options */
4439     parse_options(argc, argv, options, opt_output_file);
4440
4441     if(nb_output_files <= 0 && nb_input_files == 0) {
4442         show_usage();
4443         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4444         ffmpeg_exit(1);
4445     }
4446
4447     /* file converter / grab */
4448     if (nb_output_files <= 0) {
4449         fprintf(stderr, "At least one output file must be specified\n");
4450         ffmpeg_exit(1);
4451     }
4452
4453     if (nb_input_files == 0) {
4454         fprintf(stderr, "At least one input file must be specified\n");
4455         ffmpeg_exit(1);
4456     }
4457
4458     ti = getutime();
4459     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4460                   stream_maps, nb_stream_maps) < 0)
4461         ffmpeg_exit(1);
4462     ti = getutime() - ti;
4463     if (do_benchmark) {
4464         int maxrss = getmaxrss() / 1024;
4465         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4466     }
4467
4468     return ffmpeg_exit(0);
4469 }