avconv.c

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