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