git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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