ffmpeg.c

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