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