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

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