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

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