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

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