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

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