ffmpeg.c

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