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