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