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