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

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