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

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