avconv.c

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