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