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