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