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