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             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){
2241                 codec->time_base = icodec->time_base;
2242                 codec->time_base.num *= icodec->ticks_per_frame;
2243                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2244                           codec->time_base.num, codec->time_base.den, INT_MAX);
2245             }else
2246                 codec->time_base = ist->st->time_base;
2247             switch(codec->codec_type) {
2248             case AVMEDIA_TYPE_AUDIO:
2249                 if(audio_volume != 256) {
2250                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2251                     ffmpeg_exit(1);
2252                 }
2253                 codec->channel_layout = icodec->channel_layout;
2254                 codec->sample_rate = icodec->sample_rate;
2255                 codec->channels = icodec->channels;
2256                 codec->frame_size = icodec->frame_size;
2257                 codec->audio_service_type = icodec->audio_service_type;
2258                 codec->block_align= icodec->block_align;
2259                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2260                     codec->block_align= 0;
2261                 if(codec->codec_id == CODEC_ID_AC3)
2262                     codec->block_align= 0;
2263                 break;
2264             case AVMEDIA_TYPE_VIDEO:
2265                 codec->pix_fmt = icodec->pix_fmt;
2266                 codec->width = icodec->width;
2267                 codec->height = icodec->height;
2268                 codec->has_b_frames = icodec->has_b_frames;
2269                 if (!codec->sample_aspect_ratio.num) {
2270                     codec->sample_aspect_ratio =
2271                     ost->st->sample_aspect_ratio =
2272                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2273                         ist->st->codec->sample_aspect_ratio.num ?
2274                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2275                 }
2276                 break;
2277             case AVMEDIA_TYPE_SUBTITLE:
2278                 codec->width = icodec->width;
2279                 codec->height = icodec->height;
2280                 break;
2281             case AVMEDIA_TYPE_DATA:
2282                 break;
2283             default:
2284                 abort();
2285             }
2286         } else {
2287             if (!ost->enc)
2288                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2289             switch(codec->codec_type) {
2290             case AVMEDIA_TYPE_AUDIO:
2291                 ost->fifo= av_fifo_alloc(1024);
2292                 if(!ost->fifo)
2293                     goto fail;
2294                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2295                 if (!codec->sample_rate) {
2296                     codec->sample_rate = icodec->sample_rate;
2297                 }
2298                 choose_sample_rate(ost->st, ost->enc);
2299                 codec->time_base = (AVRational){1, codec->sample_rate};
2300                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2301                     codec->sample_fmt = icodec->sample_fmt;
2302                 choose_sample_fmt(ost->st, ost->enc);
2303                 if (!codec->channels) {
2304                     codec->channels = icodec->channels;
2305                     codec->channel_layout = icodec->channel_layout;
2306                 }
2307                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2308                     codec->channel_layout = 0;
2309                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2310                 icodec->request_channels = codec->channels;
2311                 ist->decoding_needed = 1;
2312                 ost->encoding_needed = 1;
2313                 ost->resample_sample_fmt  = icodec->sample_fmt;
2314                 ost->resample_sample_rate = icodec->sample_rate;
2315                 ost->resample_channels    = icodec->channels;
2316                 break;
2317             case AVMEDIA_TYPE_VIDEO:
2318                 if (codec->pix_fmt == PIX_FMT_NONE)
2319                     codec->pix_fmt = icodec->pix_fmt;
2320                 choose_pixel_fmt(ost->st, ost->enc);
2321
2322                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2323                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2324                     ffmpeg_exit(1);
2325                 }
2326                 ost->video_resample = codec->width   != icodec->width  ||
2327                                       codec->height  != icodec->height ||
2328                                       codec->pix_fmt != icodec->pix_fmt;
2329                 if (ost->video_resample) {
2330                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2331                 }
2332                 if (!codec->width || !codec->height) {
2333                     codec->width  = icodec->width;
2334                     codec->height = icodec->height;
2335                 }
2336                 ost->resample_height = icodec->height;
2337                 ost->resample_width  = icodec->width;
2338                 ost->resample_pix_fmt= icodec->pix_fmt;
2339                 ost->encoding_needed = 1;
2340                 ist->decoding_needed = 1;
2341
2342                 if (!ost->frame_rate.num)
2343                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2344                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2345                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2346                     ost->frame_rate = ost->enc->supported_framerates[idx];
2347                 }
2348                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2349                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2350                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2351                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2352                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2353                 }
2354
2355 #if CONFIG_AVFILTER
2356                 if (configure_video_filters(ist, ost)) {
2357                     fprintf(stderr, "Error opening filters!\n");
2358                     exit(1);
2359                 }
2360 #endif
2361                 break;
2362             case AVMEDIA_TYPE_SUBTITLE:
2363                 ost->encoding_needed = 1;
2364                 ist->decoding_needed = 1;
2365                 break;
2366             default:
2367                 abort();
2368                 break;
2369             }
2370             /* two pass mode */
2371             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2372                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2373                 char logfilename[1024];
2374                 FILE *f;
2375
2376                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2377                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2378                          i);
2379                 if (codec->flags & CODEC_FLAG_PASS1) {
2380                     f = fopen(logfilename, "wb");
2381                     if (!f) {
2382                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2383                         ffmpeg_exit(1);
2384                     }
2385                     ost->logfile = f;
2386                 } else {
2387                     char  *logbuffer;
2388                     size_t logbuffer_size;
2389                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2390                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2391                         ffmpeg_exit(1);
2392                     }
2393                     codec->stats_in = logbuffer;
2394                 }
2395             }
2396         }
2397         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2398             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2399             int size= codec->width * codec->height;
2400             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2401         }
2402     }
2403
2404     if (!bit_buffer)
2405         bit_buffer = av_malloc(bit_buffer_size);
2406     if (!bit_buffer) {
2407         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2408                 bit_buffer_size);
2409         ret = AVERROR(ENOMEM);
2410         goto fail;
2411     }
2412
2413     /* open each encoder */
2414     for(i=0;i<nb_ostreams;i++) {
2415         ost = ost_table[i];
2416         if (ost->encoding_needed) {
2417             AVCodec *codec = ost->enc;
2418             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2419             if (!codec) {
2420                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2421                          ost->st->codec->codec_id, ost->file_index, ost->index);
2422                 ret = AVERROR(EINVAL);
2423                 goto dump_format;
2424             }
2425             if (dec->subtitle_header) {
2426                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2427                 if (!ost->st->codec->subtitle_header) {
2428                     ret = AVERROR(ENOMEM);
2429                     goto dump_format;
2430                 }
2431                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2432                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2433             }
2434             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2435                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2436                         ost->file_index, ost->index);
2437                 ret = AVERROR(EINVAL);
2438                 goto dump_format;
2439             }
2440             assert_codec_experimental(ost->st->codec, 1);
2441             assert_avoptions(ost->opts);
2442             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2443                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2444                                              "It takes bits/s as argument, not kbits/s\n");
2445             extra_size += ost->st->codec->extradata_size;
2446         }
2447     }
2448
2449     /* open each decoder */
2450     for (i = 0; i < nb_input_streams; i++) {
2451         ist = &input_streams[i];
2452         if (ist->decoding_needed) {
2453             AVCodec *codec = ist->dec;
2454             if (!codec)
2455                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2456             if (!codec) {
2457                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2458                         ist->st->codec->codec_id, ist->file_index, ist->st->index);
2459                 ret = AVERROR(EINVAL);
2460                 goto dump_format;
2461             }
2462             if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2463                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2464                         ist->file_index, ist->st->index);
2465                 ret = AVERROR(EINVAL);
2466                 goto dump_format;
2467             }
2468             assert_codec_experimental(ist->st->codec, 0);
2469             assert_avoptions(ost->opts);
2470             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2471             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2472         }
2473     }
2474
2475     /* init pts */
2476     for (i = 0; i < nb_input_streams; i++) {
2477         AVStream *st;
2478         ist = &input_streams[i];
2479         st= ist->st;
2480         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2481         ist->next_pts = AV_NOPTS_VALUE;
2482         ist->is_start = 1;
2483     }
2484
2485     /* set meta data information from input file if required */
2486     for (i=0;i<nb_meta_data_maps;i++) {
2487         AVFormatContext *files[2];
2488         AVDictionary    **meta[2];
2489         int j;
2490
2491 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2492         if ((index) < 0 || (index) >= (nb_elems)) {\
2493             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2494                      (desc), (index));\
2495             ret = AVERROR(EINVAL);\
2496             goto dump_format;\
2497         }
2498
2499         int out_file_index = meta_data_maps[i][0].file;
2500         int in_file_index = meta_data_maps[i][1].file;
2501         if (in_file_index < 0 || out_file_index < 0)
2502             continue;
2503         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2504         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2505
2506         files[0] = output_files[out_file_index];
2507         files[1] = input_files[in_file_index].ctx;
2508
2509         for (j = 0; j < 2; j++) {
2510             MetadataMap *map = &meta_data_maps[i][j];
2511
2512             switch (map->type) {
2513             case 'g':
2514                 meta[j] = &files[j]->metadata;
2515                 break;
2516             case 's':
2517                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2518                 meta[j] = &files[j]->streams[map->index]->metadata;
2519                 break;
2520             case 'c':
2521                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2522                 meta[j] = &files[j]->chapters[map->index]->metadata;
2523                 break;
2524             case 'p':
2525                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2526                 meta[j] = &files[j]->programs[map->index]->metadata;
2527                 break;
2528             }
2529         }
2530
2531         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2532     }
2533
2534     /* copy global metadata by default */
2535     if (metadata_global_autocopy) {
2536
2537         for (i = 0; i < nb_output_files; i++)
2538             av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2539                          AV_DICT_DONT_OVERWRITE);
2540     }
2541
2542     /* copy chapters according to chapter maps */
2543     for (i = 0; i < nb_chapter_maps; i++) {
2544         int infile  = chapter_maps[i].in_file;
2545         int outfile = chapter_maps[i].out_file;
2546
2547         if (infile < 0 || outfile < 0)
2548             continue;
2549         if (infile >= nb_input_files) {
2550             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2551             ret = AVERROR(EINVAL);
2552             goto dump_format;
2553         }
2554         if (outfile >= nb_output_files) {
2555             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2556             ret = AVERROR(EINVAL);
2557             goto dump_format;
2558         }
2559         copy_chapters(infile, outfile);
2560     }
2561
2562     /* copy chapters from the first input file that has them*/
2563     if (!nb_chapter_maps)
2564         for (i = 0; i < nb_input_files; i++) {
2565             if (!input_files[i].ctx->nb_chapters)
2566                 continue;
2567
2568             for (j = 0; j < nb_output_files; j++)
2569                 if ((ret = copy_chapters(i, j)) < 0)
2570                     goto dump_format;
2571             break;
2572         }
2573
2574     /* open files and write file headers */
2575     for(i=0;i<nb_output_files;i++) {
2576         os = output_files[i];
2577         if (avformat_write_header(os, &output_opts[i]) < 0) {
2578             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2579             ret = AVERROR(EINVAL);
2580             goto dump_format;
2581         }
2582 //        assert_avoptions(output_opts[i]);
2583         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2584             want_sdp = 0;
2585         }
2586     }
2587
2588  dump_format:
2589     /* dump the file output parameters - cannot be done before in case
2590        of stream copy */
2591     for(i=0;i<nb_output_files;i++) {
2592         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2593     }
2594
2595     /* dump the stream mapping */
2596     if (verbose >= 0) {
2597         fprintf(stderr, "Stream mapping:\n");
2598         for(i=0;i<nb_ostreams;i++) {
2599             ost = ost_table[i];
2600             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2601                     input_streams[ost->source_index].file_index,
2602                     input_streams[ost->source_index].st->index,
2603                     ost->file_index,
2604                     ost->index);
2605             if (ost->sync_ist != &input_streams[ost->source_index])
2606                 fprintf(stderr, " [sync #%d.%d]",
2607                         ost->sync_ist->file_index,
2608                         ost->sync_ist->st->index);
2609             fprintf(stderr, "\n");
2610         }
2611     }
2612
2613     if (ret) {
2614         fprintf(stderr, "%s\n", error);
2615         goto fail;
2616     }
2617
2618     if (want_sdp) {
2619         print_sdp(output_files, nb_output_files);
2620     }
2621
2622     if (!using_stdin) {
2623         if(verbose >= 0)
2624             fprintf(stderr, "Press [q] to stop, [?] for help\n");
2625         avio_set_interrupt_cb(decode_interrupt_cb);
2626     }
2627     term_init();
2628
2629     timer_start = av_gettime();
2630
2631     for(; received_sigterm == 0;) {
2632         int file_index, ist_index;
2633         AVPacket pkt;
2634         double ipts_min;
2635         double opts_min;
2636
2637     redo:
2638         ipts_min= 1e100;
2639         opts_min= 1e100;
2640         /* if 'q' pressed, exits */
2641         if (!using_stdin) {
2642             if (q_pressed)
2643                 break;
2644             /* read_key() returns 0 on EOF */
2645             key = read_key();
2646             if (key == 'q')
2647                 break;
2648             if (key == '+') verbose++;
2649             if (key == '-') verbose--;
2650             if (key == 's') qp_hist     ^= 1;
2651             if (key == 'h'){
2652                 if (do_hex_dump){
2653                     do_hex_dump = do_pkt_dump = 0;
2654                 } else if(do_pkt_dump){
2655                     do_hex_dump = 1;
2656                 } else
2657                     do_pkt_dump = 1;
2658                 av_log_set_level(AV_LOG_DEBUG);
2659             }
2660             if (key == 'd' || key == 'D'){
2661                 int debug=0;
2662                 if(key == 'D') {
2663                     debug = input_streams[0].st->codec->debug<<1;
2664                     if(!debug) debug = 1;
2665                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2666                         debug += debug;
2667                 }else
2668                     scanf("%d", &debug);
2669                 for(i=0;i<nb_input_streams;i++) {
2670                     input_streams[i].st->codec->debug = debug;
2671                 }
2672                 for(i=0;i<nb_ostreams;i++) {
2673                     ost = ost_table[i];
2674                     ost->st->codec->debug = debug;
2675                 }
2676                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2677                 fprintf(stderr,"debug=%d\n", debug);
2678             }
2679             if (key == '?'){
2680                 fprintf(stderr, "key    function\n"
2681                                 "?      show this help\n"
2682                                 "+      increase verbosity\n"
2683                                 "-      decrease verbosity\n"
2684                                 "D      cycle through available debug modes\n"
2685                                 "h      dump packets/hex press to cycle through the 3 states\n"
2686                                 "q      quit\n"
2687                                 "s      Show QP histogram\n"
2688                 );
2689             }
2690         }
2691
2692         /* select the stream that we must read now by looking at the
2693            smallest output pts */
2694         file_index = -1;
2695         for(i=0;i<nb_ostreams;i++) {
2696             double ipts, opts;
2697             ost = ost_table[i];
2698             os = output_files[ost->file_index];
2699             ist = &input_streams[ost->source_index];
2700             if(ist->is_past_recording_time || no_packet[ist->file_index])
2701                 continue;
2702                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2703             ipts = (double)ist->pts;
2704             if (!input_files[ist->file_index].eof_reached){
2705                 if(ipts < ipts_min) {
2706                     ipts_min = ipts;
2707                     if(input_sync ) file_index = ist->file_index;
2708                 }
2709                 if(opts < opts_min) {
2710                     opts_min = opts;
2711                     if(!input_sync) file_index = ist->file_index;
2712                 }
2713             }
2714             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2715                 file_index= -1;
2716                 break;
2717             }
2718         }
2719         /* if none, if is finished */
2720         if (file_index < 0) {
2721             if(no_packet_count){
2722                 no_packet_count=0;
2723                 memset(no_packet, 0, sizeof(no_packet));
2724                 usleep(10000);
2725                 continue;
2726             }
2727             break;
2728         }
2729
2730         /* finish if limit size exhausted */
2731         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2732             break;
2733
2734         /* read a frame from it and output it in the fifo */
2735         is = input_files[file_index].ctx;
2736         ret= av_read_frame(is, &pkt);
2737         if(ret == AVERROR(EAGAIN)){
2738             no_packet[file_index]=1;
2739             no_packet_count++;
2740             continue;
2741         }
2742         if (ret < 0) {
2743             input_files[file_index].eof_reached = 1;
2744             if (opt_shortest)
2745                 break;
2746             else
2747                 continue;
2748         }
2749
2750         no_packet_count=0;
2751         memset(no_packet, 0, sizeof(no_packet));
2752
2753         if (do_pkt_dump) {
2754             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2755                              is->streams[pkt.stream_index]);
2756         }
2757         /* the following test is needed in case new streams appear
2758            dynamically in stream : we ignore them */
2759         if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2760             goto discard_packet;
2761         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2762         ist = &input_streams[ist_index];
2763         if (ist->discard)
2764             goto discard_packet;
2765
2766         if (pkt.dts != AV_NOPTS_VALUE)
2767             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2768         if (pkt.pts != AV_NOPTS_VALUE)
2769             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2770
2771         if (ist->ts_scale) {
2772             if(pkt.pts != AV_NOPTS_VALUE)
2773                 pkt.pts *= ist->ts_scale;
2774             if(pkt.dts != AV_NOPTS_VALUE)
2775                 pkt.dts *= ist->ts_scale;
2776         }
2777
2778 //        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);
2779         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2780             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2781             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2782             int64_t delta= pkt_dts - ist->next_pts;
2783             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2784                 input_files[ist->file_index].ts_offset -= delta;
2785                 if (verbose > 2)
2786                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2787                             delta, input_files[ist->file_index].ts_offset);
2788                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2789                 if(pkt.pts != AV_NOPTS_VALUE)
2790                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2791             }
2792         }
2793
2794         /* finish if recording time exhausted */
2795         if (recording_time != INT64_MAX &&
2796             (pkt.pts != AV_NOPTS_VALUE ?
2797                 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2798                     :
2799                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2800             )>= 0) {
2801             ist->is_past_recording_time = 1;
2802             goto discard_packet;
2803         }
2804
2805         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2806         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2807
2808             if (verbose >= 0)
2809                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2810                         ist->file_index, ist->st->index);
2811             if (exit_on_error)
2812                 ffmpeg_exit(1);
2813             av_free_packet(&pkt);
2814             goto redo;
2815         }
2816
2817     discard_packet:
2818         av_free_packet(&pkt);
2819
2820         /* dump report by using the output first video and audio streams */
2821         print_report(output_files, ost_table, nb_ostreams, 0);
2822     }
2823
2824     /* at the end of stream, we must flush the decoder buffers */
2825     for (i = 0; i < nb_input_streams; i++) {
2826         ist = &input_streams[i];
2827         if (ist->decoding_needed) {
2828             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2829         }
2830     }
2831
2832     term_exit();
2833
2834     /* write the trailer if needed and close file */
2835     for(i=0;i<nb_output_files;i++) {
2836         os = output_files[i];
2837         av_write_trailer(os);
2838     }
2839
2840     /* dump report by using the first video and audio streams */
2841     print_report(output_files, ost_table, nb_ostreams, 1);
2842
2843     /* close each encoder */
2844     for(i=0;i<nb_ostreams;i++) {
2845         ost = ost_table[i];
2846         if (ost->encoding_needed) {
2847             av_freep(&ost->st->codec->stats_in);
2848             avcodec_close(ost->st->codec);
2849         }
2850 #if CONFIG_AVFILTER
2851         avfilter_graph_free(&ost->graph);
2852 #endif
2853     }
2854
2855     /* close each decoder */
2856     for (i = 0; i < nb_input_streams; i++) {
2857         ist = &input_streams[i];
2858         if (ist->decoding_needed) {
2859             avcodec_close(ist->st->codec);
2860         }
2861     }
2862
2863     /* finished ! */
2864     ret = 0;
2865
2866  fail:
2867     av_freep(&bit_buffer);
2868
2869     if (ost_table) {
2870         for(i=0;i<nb_ostreams;i++) {
2871             ost = ost_table[i];
2872             if (ost) {
2873                 if (ost->st->stream_copy)
2874                     av_freep(&ost->st->codec->extradata);
2875                 if (ost->logfile) {
2876                     fclose(ost->logfile);
2877                     ost->logfile = NULL;
2878                 }
2879                 av_fifo_free(ost->fifo); /* works even if fifo is not
2880                                              initialized but set to zero */
2881                 av_freep(&ost->st->codec->subtitle_header);
2882                 av_free(ost->resample_frame.data[0]);
2883                 av_free(ost->forced_kf_pts);
2884                 if (ost->video_resample)
2885                     sws_freeContext(ost->img_resample_ctx);
2886                 if (ost->resample)
2887                     audio_resample_close(ost->resample);
2888                 if (ost->reformat_ctx)
2889                     av_audio_convert_free(ost->reformat_ctx);
2890                 av_dict_free(&ost->opts);
2891                 av_free(ost);
2892             }
2893         }
2894         av_free(ost_table);
2895     }
2896     return ret;
2897 }
2898
2899 static int opt_format(const char *opt, const char *arg)
2900 {
2901     last_asked_format = arg;
2902     return 0;
2903 }
2904
2905 static int opt_video_rc_override_string(const char *opt, const char *arg)
2906 {
2907     video_rc_override_string = arg;
2908     return 0;
2909 }
2910
2911 static int opt_me_threshold(const char *opt, const char *arg)
2912 {
2913     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2914     return 0;
2915 }
2916
2917 static int opt_verbose(const char *opt, const char *arg)
2918 {
2919     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2920     return 0;
2921 }
2922
2923 static int opt_frame_rate(const char *opt, const char *arg)
2924 {
2925     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2926         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2927         ffmpeg_exit(1);
2928     }
2929     return 0;
2930 }
2931
2932 static int opt_frame_crop(const char *opt, const char *arg)
2933 {
2934     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2935     return AVERROR(EINVAL);
2936 }
2937
2938 static int opt_frame_size(const char *opt, const char *arg)
2939 {
2940     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2941         fprintf(stderr, "Incorrect frame size\n");
2942         return AVERROR(EINVAL);
2943     }
2944     return 0;
2945 }
2946
2947 static int opt_pad(const char *opt, const char *arg) {
2948     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2949     return -1;
2950 }
2951
2952 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2953 {
2954     if (strcmp(arg, "list")) {
2955         frame_pix_fmt = av_get_pix_fmt(arg);
2956         if (frame_pix_fmt == PIX_FMT_NONE) {
2957             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2958             return AVERROR(EINVAL);
2959         }
2960     } else {
2961         opt_pix_fmts(NULL, NULL);
2962         ffmpeg_exit(0);
2963     }
2964     return 0;
2965 }
2966
2967 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2968 {
2969     int x = 0, y = 0;
2970     double ar = 0;
2971     const char *p;
2972     char *end;
2973
2974     p = strchr(arg, ':');
2975     if (p) {
2976         x = strtol(arg, &end, 10);
2977         if (end == p)
2978             y = strtol(end+1, &end, 10);
2979         if (x > 0 && y > 0)
2980             ar = (double)x / (double)y;
2981     } else
2982         ar = strtod(arg, NULL);
2983
2984     if (!ar) {
2985         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2986         return AVERROR(EINVAL);
2987     }
2988     frame_aspect_ratio = ar;
2989     return 0;
2990 }
2991
2992 static int opt_metadata(const char *opt, const char *arg)
2993 {
2994     char *mid= strchr(arg, '=');
2995
2996     if(!mid){
2997         fprintf(stderr, "Missing =\n");
2998         ffmpeg_exit(1);
2999     }
3000     *mid++= 0;
3001
3002     av_dict_set(&metadata, arg, mid, 0);
3003
3004     return 0;
3005 }
3006
3007 static int opt_qscale(const char *opt, const char *arg)
3008 {
3009     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
3010     if (video_qscale <= 0 || video_qscale > 255) {
3011         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
3012         return AVERROR(EINVAL);
3013     }
3014     return 0;
3015 }
3016
3017 static int opt_top_field_first(const char *opt, const char *arg)
3018 {
3019     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
3020     opt_default(opt, arg);
3021     return 0;
3022 }
3023
3024 static int opt_thread_count(const char *opt, const char *arg)
3025 {
3026     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3027 #if !HAVE_THREADS
3028     if (verbose >= 0)
3029         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
3030 #endif
3031     return 0;
3032 }
3033
3034 static int opt_audio_sample_fmt(const char *opt, const char *arg)
3035 {
3036     if (strcmp(arg, "list")) {
3037         audio_sample_fmt = av_get_sample_fmt(arg);
3038         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
3039             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
3040             return AVERROR(EINVAL);
3041         }
3042     } else {
3043         int i;
3044         char fmt_str[128];
3045         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
3046             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
3047         ffmpeg_exit(0);
3048     }
3049     return 0;
3050 }
3051
3052 static int opt_audio_rate(const char *opt, const char *arg)
3053 {
3054     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3055     return 0;
3056 }
3057
3058 static int opt_audio_channels(const char *opt, const char *arg)
3059 {
3060     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
3061     return 0;
3062 }
3063
3064 static int opt_video_channel(const char *opt, const char *arg)
3065 {
3066     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3067     opt_default("channel", arg);
3068     return 0;
3069 }
3070
3071 static int opt_video_standard(const char *opt, const char *arg)
3072 {
3073     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3074     opt_default("standard", arg);
3075     return 0;
3076 }
3077
3078 static int opt_codec(const char *opt, const char *arg)
3079 {
3080     int *pstream_copy; char **pcodec_name; enum AVMediaType codec_type;
3081
3082     if      (!strcmp(opt, "acodec")) { pstream_copy = &audio_stream_copy;    pcodec_name = &audio_codec_name;    codec_type = AVMEDIA_TYPE_AUDIO;    }
3083     else if (!strcmp(opt, "vcodec")) { pstream_copy = &video_stream_copy;    pcodec_name = &video_codec_name;    codec_type = AVMEDIA_TYPE_VIDEO;    }
3084     else if (!strcmp(opt, "scodec")) { pstream_copy = &subtitle_stream_copy; pcodec_name = &subtitle_codec_name; codec_type = AVMEDIA_TYPE_SUBTITLE; }
3085     else if (!strcmp(opt, "dcodec")) { pstream_copy = &data_stream_copy;     pcodec_name = &data_codec_name;     codec_type = AVMEDIA_TYPE_DATA;     }
3086
3087     av_freep(pcodec_name);
3088     if (!strcmp(arg, "copy")) {
3089         *pstream_copy = 1;
3090     } else {
3091         *pcodec_name = av_strdup(arg);
3092     }
3093     return 0;
3094 }
3095
3096 static int opt_codec_tag(const char *opt, const char *arg)
3097 {
3098     char *tail;
3099     uint32_t *codec_tag;
3100
3101     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3102                 !strcmp(opt, "vtag") ? &video_codec_tag :
3103                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3104     if (!codec_tag)
3105         return -1;
3106
3107     *codec_tag = strtol(arg, &tail, 0);
3108     if (!tail || *tail)
3109         *codec_tag = AV_RL32(arg);
3110
3111     return 0;
3112 }
3113
3114 static int opt_map(const char *opt, const char *arg)
3115 {
3116     StreamMap *m;
3117     char *p;
3118
3119     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3120     m = &stream_maps[nb_stream_maps-1];
3121
3122     m->file_index = strtol(arg, &p, 0);
3123     if (*p)
3124         p++;
3125
3126     m->stream_index = strtol(p, &p, 0);
3127     if (*p) {
3128         p++;
3129         m->sync_file_index = strtol(p, &p, 0);
3130         if (*p)
3131             p++;
3132         m->sync_stream_index = strtol(p, &p, 0);
3133     } else {
3134         m->sync_file_index = m->file_index;
3135         m->sync_stream_index = m->stream_index;
3136     }
3137     return 0;
3138 }
3139
3140 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3141 {
3142     *endptr = arg;
3143     if (*arg == ',') {
3144         *type = *(++arg);
3145         switch (*arg) {
3146         case 'g':
3147             break;
3148         case 's':
3149         case 'c':
3150         case 'p':
3151             *index = strtol(++arg, endptr, 0);
3152             break;
3153         default:
3154             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3155             ffmpeg_exit(1);
3156         }
3157     } else
3158         *type = 'g';
3159 }
3160
3161 static int opt_map_metadata(const char *opt, const char *arg)
3162 {
3163     MetadataMap *m, *m1;
3164     char *p;
3165
3166     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3167                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
3168
3169     m = &meta_data_maps[nb_meta_data_maps - 1][0];
3170     m->file = strtol(arg, &p, 0);
3171     parse_meta_type(p, &m->type, &m->index, &p);
3172     if (*p)
3173         p++;
3174
3175     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3176     m1->file = strtol(p, &p, 0);
3177     parse_meta_type(p, &m1->type, &m1->index, &p);
3178
3179     if (m->type == 'g' || m1->type == 'g')
3180         metadata_global_autocopy = 0;
3181     if (m->type == 's' || m1->type == 's')
3182         metadata_streams_autocopy = 0;
3183     if (m->type == 'c' || m1->type == 'c')
3184         metadata_chapters_autocopy = 0;
3185
3186     return 0;
3187 }
3188
3189 static int opt_map_meta_data(const char *opt, const char *arg)
3190 {
3191     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3192                     "Use -map_metadata instead.\n");
3193     return opt_map_metadata(opt, arg);
3194 }
3195
3196 static int opt_map_chapters(const char *opt, const char *arg)
3197 {
3198     ChapterMap *c;
3199     char *p;
3200
3201     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3202                               nb_chapter_maps + 1);
3203     c = &chapter_maps[nb_chapter_maps - 1];
3204     c->out_file = strtol(arg, &p, 0);
3205     if (*p)
3206         p++;
3207
3208     c->in_file = strtol(p, &p, 0);
3209     return 0;
3210 }
3211
3212 static int opt_input_ts_scale(const char *opt, const char *arg)
3213 {
3214     unsigned int stream;
3215     double scale;
3216     char *p;
3217
3218     stream = strtol(arg, &p, 0);
3219     if (*p)
3220         p++;
3221     scale= strtod(p, &p);
3222
3223     if(stream >= MAX_STREAMS)
3224         ffmpeg_exit(1);
3225
3226     ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3227     ts_scale[stream] = scale;
3228     return 0;
3229 }
3230
3231 static int opt_recording_time(const char *opt, const char *arg)
3232 {
3233     recording_time = parse_time_or_die(opt, arg, 1);
3234     return 0;
3235 }
3236
3237 static int opt_start_time(const char *opt, const char *arg)
3238 {
3239     start_time = parse_time_or_die(opt, arg, 1);
3240     return 0;
3241 }
3242
3243 static int opt_recording_timestamp(const char *opt, const char *arg)
3244 {
3245     char buf[128];
3246     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3247     struct tm time = *gmtime((time_t*)&recording_timestamp);
3248     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3249     opt_metadata("metadata", buf);
3250
3251     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3252                                  "tag instead.\n", opt);
3253     return 0;
3254 }
3255
3256 static int opt_input_ts_offset(const char *opt, const char *arg)
3257 {
3258     input_ts_offset = parse_time_or_die(opt, arg, 1);
3259     return 0;
3260 }
3261
3262 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3263 {
3264     const char *codec_string = encoder ? "encoder" : "decoder";
3265     AVCodec *codec;
3266
3267     if(!name)
3268         return CODEC_ID_NONE;
3269     codec = encoder ?
3270         avcodec_find_encoder_by_name(name) :
3271         avcodec_find_decoder_by_name(name);
3272     if(!codec) {
3273         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3274         ffmpeg_exit(1);
3275     }
3276     if(codec->type != type) {
3277         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3278         ffmpeg_exit(1);
3279     }
3280     return codec->id;
3281 }
3282
3283 static int opt_input_file(const char *opt, const char *filename)
3284 {
3285     AVFormatContext *ic;
3286     AVInputFormat *file_iformat = NULL;
3287     int err, i, ret, rfps, rfps_base;
3288     int64_t timestamp;
3289     uint8_t buf[128];
3290     AVDictionary **opts;
3291     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3292
3293     if (last_asked_format) {
3294         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3295             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3296             ffmpeg_exit(1);
3297         }
3298         last_asked_format = NULL;
3299     }
3300
3301     if (!strcmp(filename, "-"))
3302         filename = "pipe:";
3303
3304     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3305                     !strcmp(filename, "/dev/stdin");
3306
3307     /* get default parameters from command line */
3308     ic = avformat_alloc_context();
3309     if (!ic) {
3310         print_error(filename, AVERROR(ENOMEM));
3311         ffmpeg_exit(1);
3312     }
3313     if (audio_sample_rate) {
3314         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3315         av_dict_set(&format_opts, "sample_rate", buf, 0);
3316     }
3317     if (audio_channels) {
3318         snprintf(buf, sizeof(buf), "%d", audio_channels);
3319         av_dict_set(&format_opts, "channels", buf, 0);
3320     }
3321     if (frame_rate.num) {
3322         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3323         av_dict_set(&format_opts, "framerate", buf, 0);
3324     }
3325     if (frame_width && frame_height) {
3326         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3327         av_dict_set(&format_opts, "video_size", buf, 0);
3328     }
3329     if (frame_pix_fmt != PIX_FMT_NONE)
3330         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3331
3332     ic->video_codec_id   =
3333         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
3334     ic->audio_codec_id   =
3335         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
3336     ic->subtitle_codec_id=
3337         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3338     ic->flags |= AVFMT_FLAG_NONBLOCK;
3339
3340     /* open the input file with generic libav function */
3341     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3342     if (err < 0) {
3343         print_error(filename, err);
3344         ffmpeg_exit(1);
3345     }
3346     assert_avoptions(format_opts);
3347
3348     if(opt_programid) {
3349         int i, j;
3350         int found=0;
3351         for(i=0; i<ic->nb_streams; i++){
3352             ic->streams[i]->discard= AVDISCARD_ALL;
3353         }
3354         for(i=0; i<ic->nb_programs; i++){
3355             AVProgram *p= ic->programs[i];
3356             if(p->id != opt_programid){
3357                 p->discard = AVDISCARD_ALL;
3358             }else{
3359                 found=1;
3360                 for(j=0; j<p->nb_stream_indexes; j++){
3361                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3362                 }
3363             }
3364         }
3365         if(!found){
3366             fprintf(stderr, "Specified program id not found\n");
3367             ffmpeg_exit(1);
3368         }
3369         opt_programid=0;
3370     }
3371
3372     if (loop_input) {
3373         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3374         ic->loop_input = loop_input;
3375     }
3376
3377     /* Set AVCodecContext options for avformat_find_stream_info */
3378     opts = setup_find_stream_info_opts(ic);
3379     orig_nb_streams = ic->nb_streams;
3380
3381     /* If not enough info to get the stream parameters, we decode the
3382        first frames to get it. (used in mpeg case for example) */
3383     ret = avformat_find_stream_info(ic, opts);
3384     if (ret < 0 && verbose >= 0) {
3385         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3386         av_close_input_file(ic);
3387         ffmpeg_exit(1);
3388     }
3389
3390     timestamp = start_time;
3391     /* add the stream start time */
3392     if (ic->start_time != AV_NOPTS_VALUE)
3393         timestamp += ic->start_time;
3394
3395     /* if seeking requested, we execute it */
3396     if (start_time != 0) {
3397         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3398         if (ret < 0) {
3399             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3400                     filename, (double)timestamp / AV_TIME_BASE);
3401         }
3402         /* reset seek info */
3403         start_time = 0;
3404     }
3405
3406     /* update the current parameters so that they match the one of the input stream */
3407     for(i=0;i<ic->nb_streams;i++) {
3408         AVStream *st = ic->streams[i];
3409         AVCodecContext *dec = st->codec;
3410         InputStream *ist;
3411
3412         dec->thread_count = thread_count;
3413
3414         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3415         ist = &input_streams[nb_input_streams - 1];
3416         ist->st = st;
3417         ist->file_index = nb_input_files;
3418         ist->discard = 1;
3419         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
3420
3421         if (i < nb_ts_scale)
3422             ist->ts_scale = ts_scale[i];
3423
3424         switch (dec->codec_type) {
3425         case AVMEDIA_TYPE_AUDIO:
3426             ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3427             if(!ist->dec)
3428                 ist->dec = avcodec_find_decoder(dec->codec_id);
3429             if(audio_disable)
3430                 st->discard= AVDISCARD_ALL;
3431             break;
3432         case AVMEDIA_TYPE_VIDEO:
3433             ist->dec= avcodec_find_decoder_by_name(video_codec_name);
3434             if(!ist->dec)
3435                 ist->dec = avcodec_find_decoder(dec->codec_id);
3436             rfps      = ic->streams[i]->r_frame_rate.num;
3437             rfps_base = ic->streams[i]->r_frame_rate.den;
3438             if (dec->lowres) {
3439                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3440             }
3441             if(me_threshold)
3442                 dec->debug |= FF_DEBUG_MV;
3443
3444             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3445
3446                 if (verbose >= 0)
3447                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3448                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3449
3450                     (float)rfps / rfps_base, rfps, rfps_base);
3451             }
3452
3453             if(video_disable)
3454                 st->discard= AVDISCARD_ALL;
3455             else if(video_discard)
3456                 st->discard= video_discard;
3457             break;
3458         case AVMEDIA_TYPE_DATA:
3459             break;
3460         case AVMEDIA_TYPE_SUBTITLE:
3461             ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3462             if(!ist->dec)
3463                 ist->dec = avcodec_find_decoder(dec->codec_id);
3464             if(subtitle_disable)
3465                 st->discard = AVDISCARD_ALL;
3466             break;
3467         case AVMEDIA_TYPE_ATTACHMENT:
3468         case AVMEDIA_TYPE_UNKNOWN:
3469             break;
3470         default:
3471             abort();
3472         }
3473     }
3474
3475     /* dump the file content */
3476     if (verbose >= 0)
3477         av_dump_format(ic, nb_input_files, filename, 0);
3478
3479     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3480     input_files[nb_input_files - 1].ctx        = ic;
3481     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3482     input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);
3483
3484     top_field_first = -1;
3485     frame_rate    = (AVRational){0, 0};
3486     frame_pix_fmt = PIX_FMT_NONE;
3487     frame_height = 0;
3488     frame_width  = 0;
3489     audio_sample_rate = 0;
3490     audio_channels    = 0;
3491     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3492     av_freep(&ts_scale);
3493     nb_ts_scale = 0;
3494
3495     for (i = 0; i < orig_nb_streams; i++)
3496         av_dict_free(&opts[i]);
3497     av_freep(&opts);
3498     av_freep(&video_codec_name);
3499     av_freep(&audio_codec_name);
3500     av_freep(&subtitle_codec_name);
3501     uninit_opts();
3502     init_opts();
3503     return 0;
3504 }
3505
3506 static void check_inputs(int *has_video_ptr,
3507                          int *has_audio_ptr,
3508                          int *has_subtitle_ptr,
3509                          int *has_data_ptr)
3510 {
3511     int has_video, has_audio, has_subtitle, has_data, i, j;
3512     AVFormatContext *ic;
3513
3514     has_video = 0;
3515     has_audio = 0;
3516     has_subtitle = 0;
3517     has_data = 0;
3518
3519     for(j=0;j<nb_input_files;j++) {
3520         ic = input_files[j].ctx;
3521         for(i=0;i<ic->nb_streams;i++) {
3522             AVCodecContext *enc = ic->streams[i]->codec;
3523             switch(enc->codec_type) {
3524             case AVMEDIA_TYPE_AUDIO:
3525                 has_audio = 1;
3526                 break;
3527             case AVMEDIA_TYPE_VIDEO:
3528                 has_video = 1;
3529                 break;
3530             case AVMEDIA_TYPE_SUBTITLE:
3531                 has_subtitle = 1;
3532                 break;
3533             case AVMEDIA_TYPE_DATA:
3534             case AVMEDIA_TYPE_ATTACHMENT:
3535             case AVMEDIA_TYPE_UNKNOWN:
3536                 has_data = 1;
3537                 break;
3538             default:
3539                 abort();
3540             }
3541         }
3542     }
3543     *has_video_ptr = has_video;
3544     *has_audio_ptr = has_audio;
3545     *has_subtitle_ptr = has_subtitle;
3546     *has_data_ptr = has_data;
3547 }
3548
3549 static void new_video_stream(AVFormatContext *oc, int file_idx)
3550 {
3551     AVStream *st;
3552     OutputStream *ost;
3553     AVCodecContext *video_enc;
3554     enum CodecID codec_id = CODEC_ID_NONE;
3555     AVCodec *codec= NULL;
3556
3557     if(!video_stream_copy){
3558         if (video_codec_name) {
3559             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3560             codec = avcodec_find_encoder_by_name(video_codec_name);
3561         } else {
3562             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3563             codec = avcodec_find_encoder(codec_id);
3564         }
3565     }
3566
3567     ost = new_output_stream(oc, file_idx, codec);
3568     st  = ost->st;
3569     if (!video_stream_copy) {
3570         ost->frame_aspect_ratio = frame_aspect_ratio;
3571         frame_aspect_ratio = 0;
3572 #if CONFIG_AVFILTER
3573         ost->avfilter = vfilters;
3574         vfilters = NULL;
3575 #endif
3576     }
3577
3578     ost->bitstream_filters = video_bitstream_filters;
3579     video_bitstream_filters= NULL;
3580
3581     st->codec->thread_count= thread_count;
3582
3583     video_enc = st->codec;
3584
3585     if(video_codec_tag)
3586         video_enc->codec_tag= video_codec_tag;
3587
3588     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3589         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3590     }
3591
3592     video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3593     if (video_stream_copy) {
3594         st->stream_copy = 1;
3595         video_enc->sample_aspect_ratio =
3596         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3597     } else {
3598         const char *p;
3599         int i;
3600
3601         if (frame_rate.num)
3602             ost->frame_rate = frame_rate;
3603         video_enc->codec_id = codec_id;
3604
3605         video_enc->width = frame_width;
3606         video_enc->height = frame_height;
3607         video_enc->pix_fmt = frame_pix_fmt;
3608         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3609         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3610
3611         if (intra_only)
3612             video_enc->gop_size = 0;
3613         if (video_qscale || same_quality) {
3614             video_enc->flags |= CODEC_FLAG_QSCALE;
3615             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3616         }
3617
3618         if(intra_matrix)
3619             video_enc->intra_matrix = intra_matrix;
3620         if(inter_matrix)
3621             video_enc->inter_matrix = inter_matrix;
3622
3623         p= video_rc_override_string;
3624         for(i=0; p; i++){
3625             int start, end, q;
3626             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3627             if(e!=3){
3628                 fprintf(stderr, "error parsing rc_override\n");
3629                 ffmpeg_exit(1);
3630             }
3631             video_enc->rc_override=
3632                 av_realloc(video_enc->rc_override,
3633                            sizeof(RcOverride)*(i+1));
3634             video_enc->rc_override[i].start_frame= start;
3635             video_enc->rc_override[i].end_frame  = end;
3636             if(q>0){
3637                 video_enc->rc_override[i].qscale= q;
3638                 video_enc->rc_override[i].quality_factor= 1.0;
3639             }
3640             else{
3641                 video_enc->rc_override[i].qscale= 0;
3642                 video_enc->rc_override[i].quality_factor= -q/100.0;
3643             }
3644             p= strchr(p, '/');
3645             if(p) p++;
3646         }
3647         video_enc->rc_override_count=i;
3648         if (!video_enc->rc_initial_buffer_occupancy)
3649             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3650         video_enc->me_threshold= me_threshold;
3651         video_enc->intra_dc_precision= intra_dc_precision - 8;
3652
3653         if (do_psnr)
3654             video_enc->flags|= CODEC_FLAG_PSNR;
3655
3656         /* two pass mode */
3657         if (do_pass) {
3658             if (do_pass == 1) {
3659                 video_enc->flags |= CODEC_FLAG_PASS1;
3660             } else {
3661                 video_enc->flags |= CODEC_FLAG_PASS2;
3662             }
3663         }
3664
3665         if (forced_key_frames)
3666             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3667     }
3668     if (video_language) {
3669         av_dict_set(&st->metadata, "language", video_language, 0);
3670         av_freep(&video_language);
3671     }
3672
3673     /* reset some key parameters */
3674     video_disable = 0;
3675     av_freep(&video_codec_name);
3676     av_freep(&forced_key_frames);
3677     video_stream_copy = 0;
3678     frame_pix_fmt = PIX_FMT_NONE;
3679 }
3680
3681 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3682 {
3683     AVStream *st;
3684     OutputStream *ost;
3685     AVCodec *codec= NULL;
3686     AVCodecContext *audio_enc;
3687     enum CodecID codec_id = CODEC_ID_NONE;
3688
3689     if(!audio_stream_copy){
3690         if (audio_codec_name) {
3691             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3692             codec = avcodec_find_encoder_by_name(audio_codec_name);
3693         } else {
3694             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3695             codec = avcodec_find_encoder(codec_id);
3696         }
3697     }
3698     ost = new_output_stream(oc, file_idx, codec);
3699     st  = ost->st;
3700
3701     ost->bitstream_filters = audio_bitstream_filters;
3702     audio_bitstream_filters= NULL;
3703
3704     st->codec->thread_count= thread_count;
3705
3706     audio_enc = st->codec;
3707     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3708
3709     if(audio_codec_tag)
3710         audio_enc->codec_tag= audio_codec_tag;
3711
3712     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3713         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3714     }
3715     if (audio_stream_copy) {
3716         st->stream_copy = 1;
3717     } else {
3718         audio_enc->codec_id = codec_id;
3719
3720         if (audio_qscale > QSCALE_NONE) {
3721             audio_enc->flags |= CODEC_FLAG_QSCALE;
3722             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3723         }
3724         if (audio_channels)
3725             audio_enc->channels = audio_channels;
3726         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3727             audio_enc->sample_fmt = audio_sample_fmt;
3728         if (audio_sample_rate)
3729             audio_enc->sample_rate = audio_sample_rate;
3730     }
3731     if (audio_language) {
3732         av_dict_set(&st->metadata, "language", audio_language, 0);
3733         av_freep(&audio_language);
3734     }
3735
3736     /* reset some key parameters */
3737     audio_disable = 0;
3738     av_freep(&audio_codec_name);
3739     audio_stream_copy = 0;
3740 }
3741
3742 static void new_data_stream(AVFormatContext *oc, int file_idx)
3743 {
3744     AVStream *st;
3745     OutputStream *ost;
3746     AVCodecContext *data_enc;
3747
3748     ost = new_output_stream(oc, file_idx, NULL);
3749     st  = ost->st;
3750     data_enc = st->codec;
3751     if (!data_stream_copy) {
3752         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3753         ffmpeg_exit(1);
3754     }
3755
3756     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3757
3758     if (data_codec_tag)
3759         data_enc->codec_tag= data_codec_tag;
3760
3761     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3762         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3763     }
3764     if (data_stream_copy) {
3765         st->stream_copy = 1;
3766     }
3767
3768     data_disable = 0;
3769     av_freep(&data_codec_name);
3770     data_stream_copy = 0;
3771 }
3772
3773 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3774 {
3775     AVStream *st;
3776     OutputStream *ost;
3777     AVCodec *codec=NULL;
3778     AVCodecContext *subtitle_enc;
3779     enum CodecID codec_id = CODEC_ID_NONE;
3780
3781     if(!subtitle_stream_copy){
3782         if (subtitle_codec_name) {
3783             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3784             codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3785         } else {
3786             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3787             codec = avcodec_find_encoder(codec_id);
3788         }
3789     }
3790     ost = new_output_stream(oc, file_idx, codec);
3791     st  = ost->st;
3792     subtitle_enc = st->codec;
3793
3794     ost->bitstream_filters = subtitle_bitstream_filters;
3795     subtitle_bitstream_filters= NULL;
3796
3797     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3798
3799     if(subtitle_codec_tag)
3800         subtitle_enc->codec_tag= subtitle_codec_tag;
3801
3802     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3803         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3804     }
3805     if (subtitle_stream_copy) {
3806         st->stream_copy = 1;
3807     } else {
3808         subtitle_enc->codec_id = codec_id;
3809     }
3810
3811     if (subtitle_language) {
3812         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3813         av_freep(&subtitle_language);
3814     }
3815
3816     subtitle_disable = 0;
3817     av_freep(&subtitle_codec_name);
3818     subtitle_stream_copy = 0;
3819 }
3820
3821 static int opt_new_stream(const char *opt, const char *arg)
3822 {
3823     AVFormatContext *oc;
3824     int file_idx = nb_output_files - 1;
3825     if (nb_output_files <= 0) {
3826         fprintf(stderr, "At least one output file must be specified\n");
3827         ffmpeg_exit(1);
3828     }
3829     oc = output_files[file_idx];
3830
3831     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3832     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3833     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3834     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3835     else av_assert0(0);
3836     return 0;
3837 }
3838
3839 /* arg format is "output-stream-index:streamid-value". */
3840 static int opt_streamid(const char *opt, const char *arg)
3841 {
3842     int idx;
3843     char *p;
3844     char idx_str[16];
3845
3846     av_strlcpy(idx_str, arg, sizeof(idx_str));
3847     p = strchr(idx_str, ':');
3848     if (!p) {
3849         fprintf(stderr,
3850                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3851                 arg, opt);
3852         ffmpeg_exit(1);
3853     }
3854     *p++ = '\0';
3855     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3856     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3857     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3858     return 0;
3859 }
3860
3861 static int opt_output_file(const char *opt, const char *filename)
3862 {
3863     AVFormatContext *oc;
3864     int err, use_video, use_audio, use_subtitle, use_data;
3865     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3866     AVOutputFormat *file_oformat;
3867
3868     if(nb_output_files >= FF_ARRAY_ELEMS(output_files)){
3869         fprintf(stderr, "Too many output files\n");
3870         ffmpeg_exit(1);
3871     }
3872
3873     if (!strcmp(filename, "-"))
3874         filename = "pipe:";
3875
3876     err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3877     last_asked_format = NULL;
3878     if (!oc) {
3879         print_error(filename, err);
3880         ffmpeg_exit(1);
3881     }
3882     file_oformat= oc->oformat;
3883
3884     if (!strcmp(file_oformat->name, "ffm") &&
3885         av_strstart(filename, "http:", NULL)) {
3886         /* special case for files sent to ffserver: we get the stream
3887            parameters from ffserver */
3888         int err = read_ffserver_streams(oc, filename);
3889         if (err < 0) {
3890             print_error(filename, err);
3891             ffmpeg_exit(1);
3892         }
3893     } else {
3894         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3895         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3896         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3897         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 */
3898
3899         /* disable if no corresponding type found */
3900         check_inputs(&input_has_video,
3901                      &input_has_audio,
3902                      &input_has_subtitle,
3903                      &input_has_data);
3904
3905         if (!input_has_video)
3906             use_video = 0;
3907         if (!input_has_audio)
3908             use_audio = 0;
3909         if (!input_has_subtitle)
3910             use_subtitle = 0;
3911         if (!input_has_data)
3912             use_data = 0;
3913
3914         /* manual disable */
3915         if (audio_disable)    use_audio    = 0;
3916         if (video_disable)    use_video    = 0;
3917         if (subtitle_disable) use_subtitle = 0;
3918         if (data_disable)     use_data     = 0;
3919
3920         if (use_video)    new_video_stream(oc, nb_output_files);
3921         if (use_audio)    new_audio_stream(oc, nb_output_files);
3922         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3923         if (use_data)     new_data_stream(oc, nb_output_files);
3924
3925         av_dict_copy(&oc->metadata, metadata, 0);
3926         av_dict_free(&metadata);
3927     }
3928
3929     av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3930     output_files[nb_output_files++] = oc;
3931
3932     /* check filename in case of an image number is expected */
3933     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3934         if (!av_filename_number_test(oc->filename)) {
3935             print_error(oc->filename, AVERROR(EINVAL));
3936             ffmpeg_exit(1);
3937         }
3938     }
3939
3940     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3941         /* test if it already exists to avoid loosing precious files */
3942         if (!file_overwrite &&
3943             (strchr(filename, ':') == NULL ||
3944              filename[1] == ':' ||
3945              av_strstart(filename, "file:", NULL))) {
3946             if (avio_check(filename, 0) == 0) {
3947                 if (!using_stdin) {
3948                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3949                     fflush(stderr);
3950                     if (!read_yesno()) {
3951                         fprintf(stderr, "Not overwriting - exiting\n");
3952                         ffmpeg_exit(1);
3953                     }
3954                 }
3955                 else {
3956                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3957                     ffmpeg_exit(1);
3958                 }
3959             }
3960         }
3961
3962         /* open the file */
3963         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3964             print_error(filename, err);
3965             ffmpeg_exit(1);
3966         }
3967     }
3968
3969     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3970     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3971
3972     if (loop_output >= 0) {
3973         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3974         oc->loop_output = loop_output;
3975     }
3976     oc->flags |= AVFMT_FLAG_NONBLOCK;
3977
3978     frame_rate    = (AVRational){0, 0};
3979     frame_width   = 0;
3980     frame_height  = 0;
3981     audio_sample_rate = 0;
3982     audio_channels    = 0;
3983     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3984
3985     av_freep(&forced_key_frames);
3986     uninit_opts();
3987     init_opts();
3988     return 0;
3989 }
3990
3991 /* same option as mencoder */
3992 static int opt_pass(const char *opt, const char *arg)
3993 {
3994     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3995     return 0;
3996 }
3997
3998 static int64_t getutime(void)
3999 {
4000 #if HAVE_GETRUSAGE
4001     struct rusage rusage;
4002
4003     getrusage(RUSAGE_SELF, &rusage);
4004     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4005 #elif HAVE_GETPROCESSTIMES
4006     HANDLE proc;
4007     FILETIME c, e, k, u;
4008     proc = GetCurrentProcess();
4009     GetProcessTimes(proc, &c, &e, &k, &u);
4010     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4011 #else
4012     return av_gettime();
4013 #endif
4014 }
4015
4016 static int64_t getmaxrss(void)
4017 {
4018 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4019     struct rusage rusage;
4020     getrusage(RUSAGE_SELF, &rusage);
4021     return (int64_t)rusage.ru_maxrss * 1024;
4022 #elif HAVE_GETPROCESSMEMORYINFO
4023     HANDLE proc;
4024     PROCESS_MEMORY_COUNTERS memcounters;
4025     proc = GetCurrentProcess();
4026     memcounters.cb = sizeof(memcounters);
4027     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4028     return memcounters.PeakPagefileUsage;
4029 #else
4030     return 0;
4031 #endif
4032 }
4033
4034 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4035 {
4036     int i;
4037     const char *p = str;
4038     for(i = 0;; i++) {
4039         dest[i] = atoi(p);
4040         if(i == 63)
4041             break;
4042         p = strchr(p, ',');
4043         if(!p) {
4044             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4045             ffmpeg_exit(1);
4046         }
4047         p++;
4048     }
4049 }
4050
4051 static int opt_inter_matrix(const char *opt, const char *arg)
4052 {
4053     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4054     parse_matrix_coeffs(inter_matrix, arg);
4055     return 0;
4056 }
4057
4058 static int opt_intra_matrix(const char *opt, const char *arg)
4059 {
4060     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4061     parse_matrix_coeffs(intra_matrix, arg);
4062     return 0;
4063 }
4064
4065 static void show_usage(void)
4066 {
4067     printf("Hyper fast Audio and Video encoder\n");
4068     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4069     printf("\n");
4070 }
4071
4072 static int opt_help(const char *opt, const char *arg)
4073 {
4074     AVCodec *c;
4075     AVOutputFormat *oformat = NULL;
4076     AVInputFormat  *iformat = NULL;
4077
4078     av_log_set_callback(log_callback_help);
4079     show_usage();
4080     show_help_options(options, "Main options:\n",
4081                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4082     show_help_options(options, "\nAdvanced options:\n",
4083                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4084                       OPT_EXPERT);
4085     show_help_options(options, "\nVideo options:\n",
4086                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4087                       OPT_VIDEO);
4088     show_help_options(options, "\nAdvanced Video options:\n",
4089                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4090                       OPT_VIDEO | OPT_EXPERT);
4091     show_help_options(options, "\nAudio options:\n",
4092                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4093                       OPT_AUDIO);
4094     show_help_options(options, "\nAdvanced Audio options:\n",
4095                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4096                       OPT_AUDIO | OPT_EXPERT);
4097     show_help_options(options, "\nSubtitle options:\n",
4098                       OPT_SUBTITLE | OPT_GRAB,
4099                       OPT_SUBTITLE);
4100     show_help_options(options, "\nAudio/Video grab options:\n",
4101                       OPT_GRAB,
4102                       OPT_GRAB);
4103     printf("\n");
4104     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4105     printf("\n");
4106
4107     /* individual codec options */
4108     c = NULL;
4109     while ((c = av_codec_next(c))) {
4110         if (c->priv_class) {
4111             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4112             printf("\n");
4113         }
4114     }
4115
4116     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4117     printf("\n");
4118
4119     /* individual muxer options */
4120     while ((oformat = av_oformat_next(oformat))) {
4121         if (oformat->priv_class) {
4122             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4123             printf("\n");
4124         }
4125     }
4126
4127     /* individual demuxer options */
4128     while ((iformat = av_iformat_next(iformat))) {
4129         if (iformat->priv_class) {
4130             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4131             printf("\n");
4132         }
4133     }
4134
4135     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4136     return 0;
4137 }
4138
4139 static int opt_target(const char *opt, const char *arg)
4140 {
4141     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4142     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4143
4144     if(!strncmp(arg, "pal-", 4)) {
4145         norm = PAL;
4146         arg += 4;
4147     } else if(!strncmp(arg, "ntsc-", 5)) {
4148         norm = NTSC;
4149         arg += 5;
4150     } else if(!strncmp(arg, "film-", 5)) {
4151         norm = FILM;
4152         arg += 5;
4153     } else {
4154         int fr;
4155         /* Calculate FR via float to avoid int overflow */
4156         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4157         if(fr == 25000) {
4158             norm = PAL;
4159         } else if((fr == 29970) || (fr == 23976)) {
4160             norm = NTSC;
4161         } else {
4162             /* Try to determine PAL/NTSC by peeking in the input files */
4163             if(nb_input_files) {
4164                 int i, j;
4165                 for (j = 0; j < nb_input_files; j++) {
4166                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4167                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4168                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4169                             continue;
4170                         fr = c->time_base.den * 1000 / c->time_base.num;
4171                         if(fr == 25000) {
4172                             norm = PAL;
4173                             break;
4174                         } else if((fr == 29970) || (fr == 23976)) {
4175                             norm = NTSC;
4176                             break;
4177                         }
4178                     }
4179                     if(norm != UNKNOWN)
4180                         break;
4181                 }
4182             }
4183         }
4184         if(verbose > 0 && norm != UNKNOWN)
4185             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4186     }
4187
4188     if(norm == UNKNOWN) {
4189         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4190         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4191         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4192         ffmpeg_exit(1);
4193     }
4194
4195     if(!strcmp(arg, "vcd")) {
4196         opt_codec("vcodec", "mpeg1video");
4197         opt_codec("acodec", "mp2");
4198         opt_format("f", "vcd");
4199
4200         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4201         opt_frame_rate("r", frame_rates[norm]);
4202         opt_default("g", norm == PAL ? "15" : "18");
4203
4204         opt_default("b", "1150000");
4205         opt_default("maxrate", "1150000");
4206         opt_default("minrate", "1150000");
4207         opt_default("bufsize", "327680"); // 40*1024*8;
4208
4209         opt_default("ab", "224000");
4210         audio_sample_rate = 44100;
4211         audio_channels = 2;
4212
4213         opt_default("packetsize", "2324");
4214         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4215
4216         /* We have to offset the PTS, so that it is consistent with the SCR.
4217            SCR starts at 36000, but the first two packs contain only padding
4218            and the first pack from the other stream, respectively, may also have
4219            been written before.
4220            So the real data starts at SCR 36000+3*1200. */
4221         mux_preload= (36000+3*1200) / 90000.0; //0.44
4222     } else if(!strcmp(arg, "svcd")) {
4223
4224         opt_codec("vcodec", "mpeg2video");
4225         opt_codec("acodec", "mp2");
4226         opt_format("f", "svcd");
4227
4228         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4229         opt_frame_rate("r", frame_rates[norm]);
4230         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4231         opt_default("g", norm == PAL ? "15" : "18");
4232
4233         opt_default("b", "2040000");
4234         opt_default("maxrate", "2516000");
4235         opt_default("minrate", "0"); //1145000;
4236         opt_default("bufsize", "1835008"); //224*1024*8;
4237         opt_default("flags", "+scan_offset");
4238
4239
4240         opt_default("ab", "224000");
4241         audio_sample_rate = 44100;
4242
4243         opt_default("packetsize", "2324");
4244
4245     } else if(!strcmp(arg, "dvd")) {
4246
4247         opt_codec("vcodec", "mpeg2video");
4248         opt_codec("acodec", "ac3");
4249         opt_format("f", "dvd");
4250
4251         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4252         opt_frame_rate("r", frame_rates[norm]);
4253         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4254         opt_default("g", norm == PAL ? "15" : "18");
4255
4256         opt_default("b", "6000000");
4257         opt_default("maxrate", "9000000");
4258         opt_default("minrate", "0"); //1500000;
4259         opt_default("bufsize", "1835008"); //224*1024*8;
4260
4261         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4262         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4263
4264         opt_default("ab", "448000");
4265         audio_sample_rate = 48000;
4266
4267     } else if(!strncmp(arg, "dv", 2)) {
4268
4269         opt_format("f", "dv");
4270
4271         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4272         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4273                           norm == PAL ? "yuv420p" : "yuv411p");
4274         opt_frame_rate("r", frame_rates[norm]);
4275
4276         audio_sample_rate = 48000;
4277         audio_channels = 2;
4278
4279     } else {
4280         fprintf(stderr, "Unknown target: %s\n", arg);
4281         return AVERROR(EINVAL);
4282     }
4283     return 0;
4284 }
4285
4286 static int opt_vstats_file(const char *opt, const char *arg)
4287 {
4288     av_free (vstats_filename);
4289     vstats_filename=av_strdup (arg);
4290     return 0;
4291 }
4292
4293 static int opt_vstats(const char *opt, const char *arg)
4294 {
4295     char filename[40];
4296     time_t today2 = time(NULL);
4297     struct tm *today = localtime(&today2);
4298
4299     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4300              today->tm_sec);
4301     return opt_vstats_file(opt, filename);
4302 }
4303
4304 static int opt_bsf(const char *opt, const char *arg)
4305 {
4306     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4307     AVBitStreamFilterContext **bsfp;
4308
4309     if(!bsfc){
4310         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4311         ffmpeg_exit(1);
4312     }
4313
4314     bsfp= *opt == 'v' ? &video_bitstream_filters :
4315           *opt == 'a' ? &audio_bitstream_filters :
4316                         &subtitle_bitstream_filters;
4317     while(*bsfp)
4318         bsfp= &(*bsfp)->next;
4319
4320     *bsfp= bsfc;
4321
4322     return 0;
4323 }
4324
4325 static int opt_preset(const char *opt, const char *arg)
4326 {
4327     FILE *f=NULL;
4328     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4329     char *codec_name = *opt == 'v' ? video_codec_name :
4330                        *opt == 'a' ? audio_codec_name :
4331                                      subtitle_codec_name;
4332
4333     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4334         fprintf(stderr, "File for preset '%s' not found\n", arg);
4335         ffmpeg_exit(1);
4336     }
4337
4338     while(!feof(f)){
4339         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4340         if(line[0] == '#' && !e)
4341             continue;
4342         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4343         if(e){
4344             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4345             ffmpeg_exit(1);
4346         }
4347         if (!strcmp(tmp, "acodec") ||
4348             !strcmp(tmp, "vcodec") ||
4349             !strcmp(tmp, "scodec") ||
4350             !strcmp(tmp, "dcodec")) {
4351             opt_codec(tmp, tmp2);
4352         }else if(opt_default(tmp, tmp2) < 0){
4353             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4354             ffmpeg_exit(1);
4355         }
4356     }
4357
4358     fclose(f);
4359
4360     return 0;
4361 }
4362
4363 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4364 {
4365 }
4366
4367 static int opt_passlogfile(const char *opt, const char *arg)
4368 {
4369     pass_logfilename_prefix = arg;
4370     opt_default("passlogfile", arg);
4371     return 0;
4372 }
4373
4374 static const OptionDef options[] = {
4375     /* main options */
4376 #include "cmdutils_common_opts.h"
4377     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4378     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4379     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4380     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4381     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4382       "outfile[,metadata]:infile[,metadata]" },
4383     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4384       "outfile[,metadata]:infile[,metadata]" },
4385     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4386     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4387     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4388     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4389     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4390     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4391     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4392     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4393     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4394     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4395       "add timings for benchmarking" },
4396     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4397     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4398       "dump each input packet" },
4399     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4400       "when dumping packets, also dump the payload" },
4401     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4402     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4403     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4404     { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4405     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4406     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4407     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4408     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4409     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4410     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4411     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4412     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4413     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4414     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4415     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4416     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4417
4418     /* video options */
4419     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4420     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4421     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4422     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4423     { "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" },
4424     { "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" },
4425     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4426     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4427     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4428     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4429     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4430     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4431     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4432     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4433     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4434     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4435     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4436     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4437     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4438     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4439     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_codec}, "force video codec ('copy' to copy stream)", "codec" },
4440     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4441     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4442       "use same quantizer as source (implies VBR)" },
4443     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4444     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4445     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4446       "deinterlace pictures" },
4447     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4448     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4449     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4450 #if CONFIG_AVFILTER
4451     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4452 #endif
4453     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4454     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4455     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4456     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4457     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4458     { "newvideo", OPT_VIDEO, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4459     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4460     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4461     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4462     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4463     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4464
4465     /* audio options */
4466     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4467     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4468     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4469     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4470     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4471     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4472     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4473     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4474     { "newaudio", OPT_AUDIO, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4475     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4476     { "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" },
4477
4478     /* subtitle options */
4479     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4480     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4481     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4482     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4483     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4484
4485     /* grab options */
4486     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4487     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4488     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4489
4490     /* muxer options */
4491     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4492     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4493
4494     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4495     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4496     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4497
4498     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4499     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4500     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4501     { "fpre", HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4502     /* data codec support */
4503     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_codec}, "force data codec ('copy' to copy stream)", "codec" },
4504
4505     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4506     { NULL, },
4507 };
4508
4509 int main(int argc, char **argv)
4510 {
4511     int64_t ti;
4512
4513     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4514
4515     if(argc>1 && !strcmp(argv[1], "-d")){
4516         run_as_daemon=1;
4517         verbose=-1;
4518         av_log_set_callback(log_callback_null);
4519         argc--;
4520         argv++;
4521     }
4522
4523     avcodec_register_all();
4524 #if CONFIG_AVDEVICE
4525     avdevice_register_all();
4526 #endif
4527 #if CONFIG_AVFILTER
4528     avfilter_register_all();
4529 #endif
4530     av_register_all();
4531
4532 #if HAVE_ISATTY
4533     if(isatty(STDIN_FILENO))
4534         avio_set_interrupt_cb(decode_interrupt_cb);
4535 #endif
4536
4537     init_opts();
4538
4539     if(verbose>=0)
4540         show_banner();
4541
4542     /* parse options */
4543     parse_options(argc, argv, options, opt_output_file);
4544
4545     if(nb_output_files <= 0 && nb_input_files == 0) {
4546         show_usage();
4547         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4548         ffmpeg_exit(1);
4549     }
4550
4551     /* file converter / grab */
4552     if (nb_output_files <= 0) {
4553         fprintf(stderr, "At least one output file must be specified\n");
4554         ffmpeg_exit(1);
4555     }
4556
4557     if (nb_input_files == 0) {
4558         fprintf(stderr, "At least one input file must be specified\n");
4559         ffmpeg_exit(1);
4560     }
4561
4562     ti = getutime();
4563     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4564                   stream_maps, nb_stream_maps) < 0)
4565         ffmpeg_exit(1);
4566     ti = getutime() - ti;
4567     if (do_benchmark) {
4568         int maxrss = getmaxrss() / 1024;
4569         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4570     }
4571
4572     return ffmpeg_exit(0);
4573 }