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