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