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