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

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