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