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

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