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