ffmpeg.c

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