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(int ist_index, 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->source_index != ist_index || !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             ret = avpkt.size;
1680             avpkt.size = 0;
1681         }
1682
1683 #if CONFIG_AVFILTER
1684         if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1685         if (start_time == 0 || ist->pts >= start_time) {
1686             for(i=0;i<nb_ostreams;i++) {
1687                 ost = &ost_table[i];
1688                 if (ost->input_video_filter && ost->source_index == ist_index) {
1689                     if (!picture.sample_aspect_ratio.num)
1690                         picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1691                     picture.pts = ist->pts;
1692
1693                     av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1694                 }
1695             }
1696         }
1697 #endif
1698
1699         // preprocess audio (volume)
1700         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1701             if (audio_volume != 256) {
1702                 short *volp;
1703                 volp = samples;
1704                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1705                     int v = ((*volp) * audio_volume + 128) >> 8;
1706                     if (v < -32768) v = -32768;
1707                     if (v >  32767) v = 32767;
1708                     *volp++ = v;
1709                 }
1710             }
1711         }
1712
1713         /* frame rate emulation */
1714         if (rate_emu) {
1715             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1716             int64_t now = av_gettime() - ist->start;
1717             if (pts > now)
1718                 usleep(pts - now);
1719         }
1720         /* if output time reached then transcode raw format,
1721            encode packets and output them */
1722         for (i = 0; i < nb_ostreams; i++) {
1723             OutputFile *of = &output_files[ost_table[i].file_index];
1724             int frame_size;
1725
1726             ost = &ost_table[i];
1727             if (ost->source_index != ist_index)
1728                 continue;
1729
1730             if (of->start_time && ist->pts < of->start_time)
1731                 continue;
1732
1733             if (of->recording_time != INT64_MAX &&
1734                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1735                               (AVRational){1, 1000000}) >= 0) {
1736                 ost->is_past_recording_time = 1;
1737                 continue;
1738             }
1739
1740 #if CONFIG_AVFILTER
1741             frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1742                 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1743             while (frame_available) {
1744                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1745                     AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1746                     if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1747                         goto cont;
1748                     if (ost->picref) {
1749                         avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1750                         ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1751                     }
1752                 }
1753 #endif
1754                 os = output_files[ost->file_index].ctx;
1755
1756                 /* set the input output pts pairs */
1757                 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1758
1759                 if (ost->encoding_needed) {
1760                     av_assert0(ist->decoding_needed);
1761                     switch(ost->st->codec->codec_type) {
1762                     case AVMEDIA_TYPE_AUDIO:
1763                         do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1764                         break;
1765                     case AVMEDIA_TYPE_VIDEO:
1766 #if CONFIG_AVFILTER
1767                         if (ost->picref->video && !ost->frame_aspect_ratio)
1768                             ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1769 #endif
1770                         do_video_out(os, ost, ist, &picture, &frame_size,
1771                                         same_quant ? quality : ost->st->codec->global_quality);
1772                         if (vstats_filename && frame_size)
1773                             do_video_stats(os, ost, frame_size);
1774                         break;
1775                     case AVMEDIA_TYPE_SUBTITLE:
1776                         do_subtitle_out(os, ost, ist, &subtitle,
1777                                         pkt->pts);
1778                         break;
1779                     default:
1780                         abort();
1781                     }
1782                 } else {
1783                     AVFrame avframe; //FIXME/XXX remove this
1784                     AVPicture pict;
1785                     AVPacket opkt;
1786                     int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1787                     av_init_packet(&opkt);
1788
1789                     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1790 #if !CONFIG_AVFILTER
1791                         continue;
1792 #else
1793                         goto cont;
1794 #endif
1795
1796                     /* no reencoding needed : output the packet directly */
1797                     /* force the input stream PTS */
1798
1799                     avcodec_get_frame_defaults(&avframe);
1800                     ost->st->codec->coded_frame= &avframe;
1801                     avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1802
1803                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1804                         audio_size += data_size;
1805                     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1806                         video_size += data_size;
1807                         ost->sync_opts++;
1808                     }
1809
1810                     opkt.stream_index= ost->index;
1811                     if(pkt->pts != AV_NOPTS_VALUE)
1812                         opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1813                     else
1814                         opkt.pts= AV_NOPTS_VALUE;
1815
1816                     if (pkt->dts == AV_NOPTS_VALUE)
1817                         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1818                     else
1819                         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1820                     opkt.dts -= ost_tb_start_time;
1821
1822                     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1823                     opkt.flags= pkt->flags;
1824
1825                     //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1826                     if(   ost->st->codec->codec_id != CODEC_ID_H264
1827                        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1828                        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1829                        ) {
1830                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1831                             opkt.destruct= av_destruct_packet;
1832                     } else {
1833                         opkt.data = data_buf;
1834                         opkt.size = data_size;
1835                     }
1836
1837                     if (os->oformat->flags & AVFMT_RAWPICTURE) {
1838                         /* store AVPicture in AVPacket, as expected by the output format */
1839                         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1840                         opkt.data = (uint8_t *)&pict;
1841                         opkt.size = sizeof(AVPicture);
1842                         opkt.flags |= AV_PKT_FLAG_KEY;
1843                     }
1844                     write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1845                     ost->st->codec->frame_number++;
1846                     ost->frame_number++;
1847                     av_free_packet(&opkt);
1848                 }
1849 #if CONFIG_AVFILTER
1850                 cont:
1851                 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1852                                    ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1853                 avfilter_unref_buffer(ost->picref);
1854             }
1855 #endif
1856         }
1857
1858         av_free(buffer_to_free);
1859         /* XXX: allocate the subtitles in the codec ? */
1860         if (subtitle_to_free) {
1861             avsubtitle_free(subtitle_to_free);
1862             subtitle_to_free = NULL;
1863         }
1864     }
1865  discard_packet:
1866     if (pkt == NULL) {
1867         /* EOF handling */
1868         flush_encoders(ist_index, ost_table, nb_ostreams);
1869     }
1870
1871     return 0;
1872 }
1873
1874 static void print_sdp(OutputFile *output_files, int n)
1875 {
1876     char sdp[2048];
1877     int i;
1878     AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1879
1880     if (!avc)
1881         exit_program(1);
1882     for (i = 0; i < n; i++)
1883         avc[i] = output_files[i].ctx;
1884
1885     av_sdp_create(avc, n, sdp, sizeof(sdp));
1886     printf("SDP:\n%s\n", sdp);
1887     fflush(stdout);
1888     av_freep(&avc);
1889 }
1890
1891 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1892                              char *error, int error_len)
1893 {
1894     int i;
1895     InputStream *ist = &input_streams[ist_index];
1896     if (ist->decoding_needed) {
1897         AVCodec *codec = ist->dec;
1898         if (!codec)
1899             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1900         if (!codec) {
1901             snprintf(error, sizeof(error), "Decoder (codec %s) not found for input stream #%d.%d",
1902                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1903             return AVERROR(EINVAL);
1904         }
1905         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1906             snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
1907                     ist->file_index, ist->st->index);
1908             return AVERROR(EINVAL);
1909         }
1910         assert_codec_experimental(ist->st->codec, 0);
1911         assert_avoptions(ist->opts);
1912     }
1913
1914     ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1915     ist->next_pts = AV_NOPTS_VALUE;
1916     ist->is_start = 1;
1917
1918     return 0;
1919 }
1920
1921 /*
1922  * The following code is the main loop of the file converter
1923  */
1924 static int transcode(OutputFile *output_files,
1925                      int nb_output_files,
1926                      InputFile *input_files,
1927                      int nb_input_files)
1928 {
1929     int ret = 0, i;
1930     AVFormatContext *is, *os;
1931     AVCodecContext *codec, *icodec;
1932     OutputStream *ost;
1933     InputStream *ist;
1934     char error[1024];
1935     int key;
1936     int want_sdp = 1;
1937     uint8_t *no_packet;
1938     int no_packet_count=0;
1939     int64_t timer_start;
1940
1941     if (!(no_packet = av_mallocz(nb_input_files)))
1942         exit_program(1);
1943
1944     if (rate_emu)
1945         for (i = 0; i < nb_input_streams; i++)
1946             input_streams[i].start = av_gettime();
1947
1948     /* output stream init */
1949     for(i=0;i<nb_output_files;i++) {
1950         os = output_files[i].ctx;
1951         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1952             av_dump_format(os, i, os->filename, 1);
1953             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1954             ret = AVERROR(EINVAL);
1955             goto fail;
1956         }
1957     }
1958
1959     /* for each output stream, we compute the right encoding parameters */
1960     for (i = 0; i < nb_output_streams; i++) {
1961         ost = &output_streams[i];
1962         os = output_files[ost->file_index].ctx;
1963         ist = &input_streams[ost->source_index];
1964
1965         codec = ost->st->codec;
1966         icodec = ist->st->codec;
1967
1968         ost->st->disposition = ist->st->disposition;
1969         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1970         codec->chroma_sample_location = icodec->chroma_sample_location;
1971
1972         if (ost->st->stream_copy) {
1973             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1974
1975             if (extra_size > INT_MAX) {
1976                 ret = AVERROR(EINVAL);
1977                 goto fail;
1978             }
1979
1980             /* if stream_copy is selected, no need to decode or encode */
1981             codec->codec_id = icodec->codec_id;
1982             codec->codec_type = icodec->codec_type;
1983
1984             if(!codec->codec_tag){
1985                 if(   !os->oformat->codec_tag
1986                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1987                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1988                     codec->codec_tag = icodec->codec_tag;
1989             }
1990
1991             codec->bit_rate = icodec->bit_rate;
1992             codec->rc_max_rate    = icodec->rc_max_rate;
1993             codec->rc_buffer_size = icodec->rc_buffer_size;
1994             codec->extradata= av_mallocz(extra_size);
1995             if (!codec->extradata) {
1996                 ret = AVERROR(ENOMEM);
1997                 goto fail;
1998             }
1999             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2000             codec->extradata_size= icodec->extradata_size;
2001
2002             codec->time_base = ist->st->time_base;
2003             if(!strcmp(os->oformat->name, "avi")) {
2004                 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){
2005                     codec->time_base = icodec->time_base;
2006                     codec->time_base.num *= icodec->ticks_per_frame;
2007                     codec->time_base.den *= 2;
2008                 }
2009             } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2010                 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){
2011                     codec->time_base = icodec->time_base;
2012                     codec->time_base.num *= icodec->ticks_per_frame;
2013                 }
2014             }
2015             av_reduce(&codec->time_base.num, &codec->time_base.den,
2016                         codec->time_base.num, codec->time_base.den, INT_MAX);
2017
2018             switch(codec->codec_type) {
2019             case AVMEDIA_TYPE_AUDIO:
2020                 if(audio_volume != 256) {
2021                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2022                     exit_program(1);
2023                 }
2024                 codec->channel_layout = icodec->channel_layout;
2025                 codec->sample_rate = icodec->sample_rate;
2026                 codec->channels = icodec->channels;
2027                 codec->frame_size = icodec->frame_size;
2028                 codec->audio_service_type = icodec->audio_service_type;
2029                 codec->block_align= icodec->block_align;
2030                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2031                     codec->block_align= 0;
2032                 if(codec->codec_id == CODEC_ID_AC3)
2033                     codec->block_align= 0;
2034                 break;
2035             case AVMEDIA_TYPE_VIDEO:
2036                 codec->pix_fmt = icodec->pix_fmt;
2037                 codec->width = icodec->width;
2038                 codec->height = icodec->height;
2039                 codec->has_b_frames = icodec->has_b_frames;
2040                 if (!codec->sample_aspect_ratio.num) {
2041                     codec->sample_aspect_ratio =
2042                     ost->st->sample_aspect_ratio =
2043                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2044                         ist->st->codec->sample_aspect_ratio.num ?
2045                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2046                 }
2047                 break;
2048             case AVMEDIA_TYPE_SUBTITLE:
2049                 codec->width = icodec->width;
2050                 codec->height = icodec->height;
2051                 break;
2052             case AVMEDIA_TYPE_DATA:
2053                 break;
2054             default:
2055                 abort();
2056             }
2057         } else {
2058             if (!ost->enc)
2059                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2060             switch(codec->codec_type) {
2061             case AVMEDIA_TYPE_AUDIO:
2062                 ost->fifo= av_fifo_alloc(1024);
2063                 if (!ost->fifo) {
2064                     ret = AVERROR(ENOMEM);
2065                     goto fail;
2066                 }
2067                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2068                 if (!codec->sample_rate) {
2069                     codec->sample_rate = icodec->sample_rate;
2070                 }
2071                 choose_sample_rate(ost->st, ost->enc);
2072                 codec->time_base = (AVRational){1, codec->sample_rate};
2073                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2074                     codec->sample_fmt = icodec->sample_fmt;
2075                 choose_sample_fmt(ost->st, ost->enc);
2076                 if (!codec->channels) {
2077                     codec->channels = icodec->channels;
2078                     codec->channel_layout = icodec->channel_layout;
2079                 }
2080                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2081                     codec->channel_layout = 0;
2082                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2083                 icodec->request_channels = codec->channels;
2084                 ist->decoding_needed = 1;
2085                 ost->encoding_needed = 1;
2086                 ost->resample_sample_fmt  = icodec->sample_fmt;
2087                 ost->resample_sample_rate = icodec->sample_rate;
2088                 ost->resample_channels    = icodec->channels;
2089                 break;
2090             case AVMEDIA_TYPE_VIDEO:
2091                 if (codec->pix_fmt == PIX_FMT_NONE)
2092                     codec->pix_fmt = icodec->pix_fmt;
2093                 choose_pixel_fmt(ost->st, ost->enc);
2094
2095                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2096                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2097                     exit_program(1);
2098                 }
2099
2100                 if (!codec->width || !codec->height) {
2101                     codec->width  = icodec->width;
2102                     codec->height = icodec->height;
2103                 }
2104
2105                 ost->video_resample = codec->width   != icodec->width  ||
2106                                       codec->height  != icodec->height ||
2107                                       codec->pix_fmt != icodec->pix_fmt;
2108                 if (ost->video_resample) {
2109                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2110                 }
2111
2112                 ost->resample_height = icodec->height;
2113                 ost->resample_width  = icodec->width;
2114                 ost->resample_pix_fmt= icodec->pix_fmt;
2115                 ost->encoding_needed = 1;
2116                 ist->decoding_needed = 1;
2117
2118                 if (!ost->frame_rate.num)
2119                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2120                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2121                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2122                     ost->frame_rate = ost->enc->supported_framerates[idx];
2123                 }
2124                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2125                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2126                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2127                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2128                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2129                 }
2130
2131 #if CONFIG_AVFILTER
2132                 if (configure_video_filters(ist, ost)) {
2133                     fprintf(stderr, "Error opening filters!\n");
2134                     exit(1);
2135                 }
2136 #endif
2137                 break;
2138             case AVMEDIA_TYPE_SUBTITLE:
2139                 ost->encoding_needed = 1;
2140                 ist->decoding_needed = 1;
2141                 break;
2142             default:
2143                 abort();
2144                 break;
2145             }
2146             /* two pass mode */
2147             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2148                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2149                 char logfilename[1024];
2150                 FILE *f;
2151
2152                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2153                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2154                          i);
2155                 if (codec->flags & CODEC_FLAG_PASS1) {
2156                     f = fopen(logfilename, "wb");
2157                     if (!f) {
2158                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2159                         exit_program(1);
2160                     }
2161                     ost->logfile = f;
2162                 } else {
2163                     char  *logbuffer;
2164                     size_t logbuffer_size;
2165                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2166                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2167                         exit_program(1);
2168                     }
2169                     codec->stats_in = logbuffer;
2170                 }
2171             }
2172         }
2173         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2174             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2175             int size= codec->width * codec->height;
2176             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2177         }
2178     }
2179
2180     if (!bit_buffer)
2181         bit_buffer = av_malloc(bit_buffer_size);
2182     if (!bit_buffer) {
2183         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2184                 bit_buffer_size);
2185         ret = AVERROR(ENOMEM);
2186         goto fail;
2187     }
2188
2189     /* open each encoder */
2190     for (i = 0; i < nb_output_streams; i++) {
2191         ost = &output_streams[i];
2192         if (ost->encoding_needed) {
2193             AVCodec *codec = ost->enc;
2194             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2195             if (!codec) {
2196                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2197                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2198                 ret = AVERROR(EINVAL);
2199                 goto dump_format;
2200             }
2201             if (dec->subtitle_header) {
2202                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2203                 if (!ost->st->codec->subtitle_header) {
2204                     ret = AVERROR(ENOMEM);
2205                     goto dump_format;
2206                 }
2207                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2208                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2209             }
2210             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2211                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2212                         ost->file_index, ost->index);
2213                 ret = AVERROR(EINVAL);
2214                 goto dump_format;
2215             }
2216             assert_codec_experimental(ost->st->codec, 1);
2217             assert_avoptions(ost->opts);
2218             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2219                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2220                                              "It takes bits/s as argument, not kbits/s\n");
2221             extra_size += ost->st->codec->extradata_size;
2222         }
2223     }
2224
2225     /* init input streams */
2226     for (i = 0; i < nb_input_streams; i++)
2227         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error)) < 0))
2228             goto dump_format;
2229
2230     /* open files and write file headers */
2231     for (i = 0; i < nb_output_files; i++) {
2232         os = output_files[i].ctx;
2233         if (avformat_write_header(os, &output_files[i].opts) < 0) {
2234             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2235             ret = AVERROR(EINVAL);
2236             goto dump_format;
2237         }
2238 //        assert_avoptions(output_files[i].opts);
2239         if (strcmp(os->oformat->name, "rtp")) {
2240             want_sdp = 0;
2241         }
2242     }
2243
2244  dump_format:
2245     /* dump the file output parameters - cannot be done before in case
2246        of stream copy */
2247     for(i=0;i<nb_output_files;i++) {
2248         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2249     }
2250
2251     /* dump the stream mapping */
2252     if (verbose >= 0) {
2253         fprintf(stderr, "Stream mapping:\n");
2254         for (i = 0; i < nb_output_streams;i ++) {
2255             ost = &output_streams[i];
2256             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2257                     input_streams[ost->source_index].file_index,
2258                     input_streams[ost->source_index].st->index,
2259                     ost->file_index,
2260                     ost->index);
2261             if (ost->sync_ist != &input_streams[ost->source_index])
2262                 fprintf(stderr, " [sync #%d.%d]",
2263                         ost->sync_ist->file_index,
2264                         ost->sync_ist->st->index);
2265             if(ost->encoding_needed)
2266                 fprintf(stderr, ": %s -> %s",
2267                     input_streams[ost->source_index].dec ?
2268                         input_streams[ost->source_index].dec->name : "?",
2269                     ost->enc ? ost->enc->name : "?");
2270             else
2271                 fprintf(stderr, ": copy");
2272             fprintf(stderr, "\n");
2273         }
2274     }
2275
2276     if (ret) {
2277         fprintf(stderr, "%s\n", error);
2278         goto fail;
2279     }
2280
2281     if (want_sdp) {
2282         print_sdp(output_files, nb_output_files);
2283     }
2284
2285     if (!using_stdin) {
2286         if(verbose >= 0)
2287             fprintf(stderr, "Press [q] to stop, [?] for help\n");
2288         avio_set_interrupt_cb(decode_interrupt_cb);
2289     }
2290     term_init();
2291
2292     timer_start = av_gettime();
2293
2294     for(; received_sigterm == 0;) {
2295         int file_index, ist_index;
2296         AVPacket pkt;
2297         int64_t ipts_min;
2298         double opts_min;
2299
2300     redo:
2301         ipts_min= INT64_MAX;
2302         opts_min= 1e100;
2303         /* if 'q' pressed, exits */
2304         if (!using_stdin) {
2305             if (q_pressed)
2306                 break;
2307             /* read_key() returns 0 on EOF */
2308             key = read_key();
2309             if (key == 'q')
2310                 break;
2311             if (key == '+') verbose++;
2312             if (key == '-') verbose--;
2313             if (key == 's') qp_hist     ^= 1;
2314             if (key == 'h'){
2315                 if (do_hex_dump){
2316                     do_hex_dump = do_pkt_dump = 0;
2317                 } else if(do_pkt_dump){
2318                     do_hex_dump = 1;
2319                 } else
2320                     do_pkt_dump = 1;
2321                 av_log_set_level(AV_LOG_DEBUG);
2322             }
2323             if (key == 'c' || key == 'C'){
2324                 char ret[4096], target[64], cmd[256], arg[256]={0};
2325                 double ts;
2326                 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2327                 if(scanf("%4095[^\n\r]%*c", ret) == 1 && sscanf(ret, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &ts, cmd, arg) >= 3){
2328                     for(i=0;i<nb_output_streams;i++) {
2329                         int r;
2330                         ost = &output_streams[i];
2331                         if(ost->graph){
2332                             if(ts<0){
2333                                 r= avfilter_graph_send_command(ost->graph, target, cmd, arg, ret, sizeof(ret), key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2334                                 fprintf(stderr, "Command reply for %d: %d, %s\n", i, r, ret);
2335                             }else{
2336                                 r= avfilter_graph_queue_command(ost->graph, target, cmd, arg, 0, ts);
2337                             }
2338                         }
2339                     }
2340                 }else{
2341                     fprintf(stderr, "Parse error\n");
2342                 }
2343             }
2344             if (key == 'd' || key == 'D'){
2345                 int debug=0;
2346                 if(key == 'D') {
2347                     debug = input_streams[0].st->codec->debug<<1;
2348                     if(!debug) debug = 1;
2349                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2350                         debug += debug;
2351                 }else
2352                     scanf("%d", &debug);
2353                 for(i=0;i<nb_input_streams;i++) {
2354                     input_streams[i].st->codec->debug = debug;
2355                 }
2356                 for(i=0;i<nb_output_streams;i++) {
2357                     ost = &output_streams[i];
2358                     ost->st->codec->debug = debug;
2359                 }
2360                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2361                 fprintf(stderr,"debug=%d\n", debug);
2362             }
2363             if (key == '?'){
2364                 fprintf(stderr, "key    function\n"
2365                                 "?      show this help\n"
2366                                 "+      increase verbosity\n"
2367                                 "-      decrease verbosity\n"
2368                                 "c      Send command to filtergraph\n"
2369                                 "D      cycle through available debug modes\n"
2370                                 "h      dump packets/hex press to cycle through the 3 states\n"
2371                                 "q      quit\n"
2372                                 "s      Show QP histogram\n"
2373                 );
2374             }
2375         }
2376
2377         /* select the stream that we must read now by looking at the
2378            smallest output pts */
2379         file_index = -1;
2380         for (i = 0; i < nb_output_streams; i++) {
2381             OutputFile *of;
2382             int64_t ipts;
2383             double  opts;
2384             ost = &output_streams[i];
2385             of = &output_files[ost->file_index];
2386             os = output_files[ost->file_index].ctx;
2387             ist = &input_streams[ost->source_index];
2388             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2389                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2390                 continue;
2391             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2392             ipts = ist->pts;
2393             if (!input_files[ist->file_index].eof_reached){
2394                 if(ipts < ipts_min) {
2395                     ipts_min = ipts;
2396                     if(input_sync ) file_index = ist->file_index;
2397                 }
2398                 if(opts < opts_min) {
2399                     opts_min = opts;
2400                     if(!input_sync) file_index = ist->file_index;
2401                 }
2402             }
2403             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2404                 file_index= -1;
2405                 break;
2406             }
2407         }
2408         /* if none, if is finished */
2409         if (file_index < 0) {
2410             if(no_packet_count){
2411                 no_packet_count=0;
2412                 memset(no_packet, 0, nb_input_files);
2413                 usleep(10000);
2414                 continue;
2415             }
2416             break;
2417         }
2418
2419         /* read a frame from it and output it in the fifo */
2420         is = input_files[file_index].ctx;
2421         ret= av_read_frame(is, &pkt);
2422         if(ret == AVERROR(EAGAIN)){
2423             no_packet[file_index]=1;
2424             no_packet_count++;
2425             continue;
2426         }
2427         if (ret < 0) {
2428             input_files[file_index].eof_reached = 1;
2429             if (opt_shortest)
2430                 break;
2431             else
2432                 continue;
2433         }
2434
2435         no_packet_count=0;
2436         memset(no_packet, 0, nb_input_files);
2437
2438         if (do_pkt_dump) {
2439             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2440                              is->streams[pkt.stream_index]);
2441         }
2442         /* the following test is needed in case new streams appear
2443            dynamically in stream : we ignore them */
2444         if (pkt.stream_index >= input_files[file_index].nb_streams)
2445             goto discard_packet;
2446         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2447         ist = &input_streams[ist_index];
2448         if (ist->discard)
2449             goto discard_packet;
2450
2451         if (pkt.dts != AV_NOPTS_VALUE)
2452             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2453         if (pkt.pts != AV_NOPTS_VALUE)
2454             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2455
2456         if (ist->ts_scale) {
2457             if(pkt.pts != AV_NOPTS_VALUE)
2458                 pkt.pts *= ist->ts_scale;
2459             if(pkt.dts != AV_NOPTS_VALUE)
2460                 pkt.dts *= ist->ts_scale;
2461         }
2462
2463 //        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);
2464         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2465             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2466             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2467             int64_t delta= pkt_dts - ist->next_pts;
2468             if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2469                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2470                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2471                 pkt_dts+1<ist->pts)&& !copy_ts){
2472                 input_files[ist->file_index].ts_offset -= delta;
2473                 if (verbose > 2)
2474                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2475                             delta, input_files[ist->file_index].ts_offset);
2476                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2477                 if(pkt.pts != AV_NOPTS_VALUE)
2478                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2479             }
2480         }
2481
2482         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2483         if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2484
2485             if (verbose >= 0)
2486                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2487                         ist->file_index, ist->st->index);
2488             if (exit_on_error)
2489                 exit_program(1);
2490             av_free_packet(&pkt);
2491             goto redo;
2492         }
2493
2494     discard_packet:
2495         av_free_packet(&pkt);
2496
2497         /* dump report by using the output first video and audio streams */
2498         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2499     }
2500
2501     /* at the end of stream, we must flush the decoder buffers */
2502     for (i = 0; i < nb_input_streams; i++) {
2503         ist = &input_streams[i];
2504         if (ist->decoding_needed) {
2505             output_packet(ist, i, output_streams, nb_output_streams, NULL);
2506         }
2507     }
2508
2509     term_exit();
2510
2511     /* write the trailer if needed and close file */
2512     for(i=0;i<nb_output_files;i++) {
2513         os = output_files[i].ctx;
2514         av_write_trailer(os);
2515     }
2516
2517     /* dump report by using the first video and audio streams */
2518     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2519
2520     /* close each encoder */
2521     for (i = 0; i < nb_output_streams; i++) {
2522         ost = &output_streams[i];
2523         if (ost->encoding_needed) {
2524             av_freep(&ost->st->codec->stats_in);
2525             avcodec_close(ost->st->codec);
2526         }
2527 #if CONFIG_AVFILTER
2528         avfilter_graph_free(&ost->graph);
2529 #endif
2530     }
2531
2532     /* close each decoder */
2533     for (i = 0; i < nb_input_streams; i++) {
2534         ist = &input_streams[i];
2535         if (ist->decoding_needed) {
2536             avcodec_close(ist->st->codec);
2537         }
2538     }
2539
2540     /* finished ! */
2541     ret = 0;
2542
2543  fail:
2544     av_freep(&bit_buffer);
2545     av_freep(&no_packet);
2546
2547     if (output_streams) {
2548         for (i = 0; i < nb_output_streams; i++) {
2549             ost = &output_streams[i];
2550             if (ost) {
2551                 if (ost->st->stream_copy)
2552                     av_freep(&ost->st->codec->extradata);
2553                 if (ost->logfile) {
2554                     fclose(ost->logfile);
2555                     ost->logfile = NULL;
2556                 }
2557                 av_fifo_free(ost->fifo); /* works even if fifo is not
2558                                              initialized but set to zero */
2559                 av_freep(&ost->st->codec->subtitle_header);
2560                 av_free(ost->resample_frame.data[0]);
2561                 av_free(ost->forced_kf_pts);
2562                 if (ost->video_resample)
2563                     sws_freeContext(ost->img_resample_ctx);
2564                 if (ost->resample)
2565                     audio_resample_close(ost->resample);
2566                 if (ost->reformat_ctx)
2567                     av_audio_convert_free(ost->reformat_ctx);
2568                 av_dict_free(&ost->opts);
2569             }
2570         }
2571     }
2572     return ret;
2573 }
2574
2575 static int opt_format(const char *opt, const char *arg)
2576 {
2577     last_asked_format = arg;
2578     return 0;
2579 }
2580
2581 static int opt_video_rc_override_string(const char *opt, const char *arg)
2582 {
2583     video_rc_override_string = arg;
2584     return 0;
2585 }
2586
2587 static int opt_me_threshold(const char *opt, const char *arg)
2588 {
2589     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2590     return 0;
2591 }
2592
2593 static int opt_verbose(const char *opt, const char *arg)
2594 {
2595     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2596     return 0;
2597 }
2598
2599 static int opt_frame_rate(const char *opt, const char *arg)
2600 {
2601     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2602         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2603         exit_program(1);
2604     }
2605     return 0;
2606 }
2607
2608 static int opt_frame_crop(const char *opt, const char *arg)
2609 {
2610     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2611     return AVERROR(EINVAL);
2612 }
2613
2614 static int opt_frame_size(const char *opt, const char *arg)
2615 {
2616     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2617         fprintf(stderr, "Incorrect frame size\n");
2618         return AVERROR(EINVAL);
2619     }
2620     return 0;
2621 }
2622
2623 static int opt_pad(const char *opt, const char *arg) {
2624     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2625     return -1;
2626 }
2627
2628 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2629 {
2630     if (strcmp(arg, "list")) {
2631         frame_pix_fmt = av_get_pix_fmt(arg);
2632         if (frame_pix_fmt == PIX_FMT_NONE) {
2633             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2634             return AVERROR(EINVAL);
2635         }
2636     } else {
2637         opt_pix_fmts(NULL, NULL);
2638         exit_program(0);
2639     }
2640     return 0;
2641 }
2642
2643 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2644 {
2645     int x = 0, y = 0;
2646     double ar = 0;
2647     const char *p;
2648     char *end;
2649
2650     p = strchr(arg, ':');
2651     if (p) {
2652         x = strtol(arg, &end, 10);
2653         if (end == p)
2654             y = strtol(end+1, &end, 10);
2655         if (x > 0 && y > 0)
2656             ar = (double)x / (double)y;
2657     } else
2658         ar = strtod(arg, NULL);
2659
2660     if (!ar) {
2661         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2662         return AVERROR(EINVAL);
2663     }
2664     frame_aspect_ratio = ar;
2665     return 0;
2666 }
2667
2668 static int opt_metadata(const char *opt, const char *arg)
2669 {
2670     char *mid= strchr(arg, '=');
2671
2672     if(!mid){
2673         fprintf(stderr, "Missing =\n");
2674         exit_program(1);
2675     }
2676     *mid++= 0;
2677
2678     av_dict_set(&metadata, arg, mid, 0);
2679
2680     return 0;
2681 }
2682
2683 static int opt_qscale(const char *opt, const char *arg)
2684 {
2685     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2686     if (video_qscale <= 0 || video_qscale > 255) {
2687         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2688         return AVERROR(EINVAL);
2689     }
2690     return 0;
2691 }
2692
2693 static int opt_top_field_first(const char *opt, const char *arg)
2694 {
2695     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2696     return opt_default(opt, arg);
2697 }
2698
2699 static int opt_thread_count(const char *opt, const char *arg)
2700 {
2701     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2702 #if !HAVE_THREADS
2703     if (verbose >= 0)
2704         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2705 #endif
2706     return 0;
2707 }
2708
2709 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2710 {
2711     if (strcmp(arg, "list")) {
2712         audio_sample_fmt = av_get_sample_fmt(arg);
2713         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2714             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2715             return AVERROR(EINVAL);
2716         }
2717     } else {
2718         int i;
2719         char fmt_str[128];
2720         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2721             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2722         exit_program(0);
2723     }
2724     return 0;
2725 }
2726
2727 static int opt_audio_rate(const char *opt, const char *arg)
2728 {
2729     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2730     return 0;
2731 }
2732
2733 static int opt_audio_channels(const char *opt, const char *arg)
2734 {
2735     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2736     return 0;
2737 }
2738
2739 static int opt_video_channel(const char *opt, const char *arg)
2740 {
2741     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2742     return opt_default("channel", arg);
2743 }
2744
2745 static int opt_video_standard(const char *opt, const char *arg)
2746 {
2747     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2748     return opt_default("standard", arg);
2749 }
2750
2751 static int opt_codec(const char *opt, const char *arg)
2752 {
2753     return av_dict_set(&codec_names, opt, arg, 0);
2754 }
2755
2756 static int opt_audio_codec(const char *opt, const char *arg)
2757 {
2758     return opt_codec("codec:a", arg);
2759 }
2760
2761 static int opt_video_codec(const char *opt, const char *arg)
2762 {
2763     return opt_codec("codec:v", arg);
2764 }
2765
2766 static int opt_subtitle_codec(const char *opt, const char *arg)
2767 {
2768     return opt_codec("codec:s", arg);
2769 }
2770
2771 static int opt_data_codec(const char *opt, const char *arg)
2772 {
2773     return opt_codec("codec:d", arg);
2774 }
2775
2776 static int opt_codec_tag(const char *opt, const char *arg)
2777 {
2778     char *tail;
2779     uint32_t *codec_tag;
2780
2781     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2782                 !strcmp(opt, "vtag") ? &video_codec_tag :
2783                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2784     if (!codec_tag)
2785         return -1;
2786
2787     *codec_tag = strtol(arg, &tail, 0);
2788     if (!tail || *tail)
2789         *codec_tag = AV_RL32(arg);
2790
2791     return 0;
2792 }
2793
2794 static int opt_map(const char *opt, const char *arg)
2795 {
2796     StreamMap *m = NULL;
2797     int i, negative = 0, file_idx;
2798     int sync_file_idx = -1, sync_stream_idx;
2799     char *p, *sync;
2800     char *map;
2801
2802     if (*arg == '-') {
2803         negative = 1;
2804         arg++;
2805     }
2806     map = av_strdup(arg);
2807
2808     /* parse sync stream first, just pick first matching stream */
2809     if (sync = strchr(map, ',')) {
2810         *sync = 0;
2811         sync_file_idx = strtol(sync + 1, &sync, 0);
2812         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2813             av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2814             exit_program(1);
2815         }
2816         if (*sync)
2817             sync++;
2818         for (i = 0; i < input_files[sync_file_idx].ctx->nb_streams; i++)
2819             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2820                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2821                 sync_stream_idx = i;
2822                 break;
2823             }
2824         if (i == input_files[sync_file_idx].ctx->nb_streams) {
2825             av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2826                                        "match any streams.\n", arg);
2827             exit_program(1);
2828         }
2829     }
2830
2831
2832     file_idx = strtol(map, &p, 0);
2833     if (file_idx >= nb_input_files || file_idx < 0) {
2834         av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2835         exit_program(1);
2836     }
2837     if (negative)
2838         /* disable some already defined maps */
2839         for (i = 0; i < nb_stream_maps; i++) {
2840             m = &stream_maps[i];
2841             if (check_stream_specifier(input_files[m->file_index].ctx,
2842                                        input_files[m->file_index].ctx->streams[m->stream_index],
2843                                        *p == ':' ? p + 1 : p) > 0)
2844                 m->disabled = 1;
2845         }
2846     else
2847         for (i = 0; i < input_files[file_idx].ctx->nb_streams; i++) {
2848             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2849                         *p == ':' ? p + 1 : p) <= 0)
2850                 continue;
2851             stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2852             m = &stream_maps[nb_stream_maps - 1];
2853
2854             m->file_index   = file_idx;
2855             m->stream_index = i;
2856
2857             if (sync_file_idx >= 0) {
2858                 m->sync_file_index   = sync_file_idx;
2859                 m->sync_stream_index = sync_stream_idx;
2860             } else {
2861                 m->sync_file_index   = file_idx;
2862                 m->sync_stream_index = i;
2863             }
2864         }
2865
2866     if (!m) {
2867         av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2868         exit_program(1);
2869     }
2870
2871     av_freep(&map);
2872     return 0;
2873 }
2874
2875 static void parse_meta_type(char *arg, char *type, int *index)
2876 {
2877     if (*arg == ':') {
2878         *type = *(++arg);
2879         switch (*arg) {
2880         case 'g':
2881             break;
2882         case 's':
2883         case 'c':
2884         case 'p':
2885             if (*(++arg) == ':')
2886                 *index = strtol(++arg, NULL, 0);
2887             break;
2888         default:
2889             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2890             exit_program(1);
2891         }
2892     } else
2893         *type = 'g';
2894 }
2895
2896 static int opt_map_metadata(const char *opt, const char *arg)
2897 {
2898     MetadataMap *m, *m1;
2899     char *p;
2900
2901     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2902                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2903
2904     m = &meta_data_maps[nb_meta_data_maps - 1][1];
2905     m->file = strtol(arg, &p, 0);
2906     parse_meta_type(p, &m->type, &m->index);
2907
2908     m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2909     if (p = strchr(opt, ':'))
2910         parse_meta_type(p, &m1->type, &m1->index);
2911     else
2912         m1->type = 'g';
2913
2914     if (m->type == 'g' || m1->type == 'g')
2915         metadata_global_autocopy = 0;
2916     if (m->type == 's' || m1->type == 's')
2917         metadata_streams_autocopy = 0;
2918     if (m->type == 'c' || m1->type == 'c')
2919         metadata_chapters_autocopy = 0;
2920
2921     return 0;
2922 }
2923
2924 static int opt_map_meta_data(const char *opt, const char *arg)
2925 {
2926     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2927                     "Use -map_metadata instead.\n");
2928     return opt_map_metadata(opt, arg);
2929 }
2930
2931 static int opt_input_ts_scale(const char *opt, const char *arg)
2932 {
2933     return av_dict_set(&ts_scale, opt, arg, 0);
2934 }
2935
2936 static int opt_recording_time(const char *opt, const char *arg)
2937 {
2938     recording_time = parse_time_or_die(opt, arg, 1);
2939     return 0;
2940 }
2941
2942 static int opt_start_time(const char *opt, const char *arg)
2943 {
2944     start_time = parse_time_or_die(opt, arg, 1);
2945     return 0;
2946 }
2947
2948 static int opt_recording_timestamp(const char *opt, const char *arg)
2949 {
2950     char buf[128];
2951     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2952     struct tm time = *gmtime((time_t*)&recording_timestamp);
2953     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2954     opt_metadata("metadata", buf);
2955
2956     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2957                                  "tag instead.\n", opt);
2958     return 0;
2959 }
2960
2961 static int opt_input_ts_offset(const char *opt, const char *arg)
2962 {
2963     input_ts_offset = parse_time_or_die(opt, arg, 1);
2964     return 0;
2965 }
2966
2967 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2968 {
2969     const char *codec_string = encoder ? "encoder" : "decoder";
2970     AVCodec *codec;
2971
2972     if(!name)
2973         return CODEC_ID_NONE;
2974     codec = encoder ?
2975         avcodec_find_encoder_by_name(name) :
2976         avcodec_find_decoder_by_name(name);
2977     if(!codec) {
2978         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2979         exit_program(1);
2980     }
2981     if(codec->type != type) {
2982         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2983         exit_program(1);
2984     }
2985     return codec->id;
2986 }
2987
2988 static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2989 {
2990     AVDictionaryEntry *e = NULL;
2991     char *codec_name = NULL;
2992     int ret;
2993
2994     while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
2995         char *p = strchr(e->key, ':');
2996
2997         if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
2998             codec_name = e->value;
2999         else if (ret < 0)
3000             exit_program(1);
3001     }
3002
3003     if (!codec_name) {
3004         if (s->oformat) {
3005             st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
3006             return avcodec_find_encoder(st->codec->codec_id);
3007         }
3008     } else if (!strcmp(codec_name, "copy"))
3009         st->stream_copy = 1;
3010     else {
3011         st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
3012         return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
3013                             avcodec_find_decoder_by_name(codec_name);
3014     }
3015
3016     return NULL;
3017 }
3018
3019 /**
3020  * Add all the streams from the given input file to the global
3021  * list of input streams.
3022  */
3023 static void add_input_streams(AVFormatContext *ic)
3024 {
3025     int i, rfps, rfps_base, ret;
3026
3027     for (i = 0; i < ic->nb_streams; i++) {
3028         AVStream *st = ic->streams[i];
3029         AVCodecContext *dec = st->codec;
3030         AVDictionaryEntry *e = NULL;
3031         InputStream *ist;
3032         char *scale = NULL;
3033
3034         dec->thread_count = thread_count;
3035
3036         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3037         ist = &input_streams[nb_input_streams - 1];
3038         ist->st = st;
3039         ist->file_index = nb_input_files;
3040         ist->discard = 1;
3041         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3042
3043         while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
3044             char *p = strchr(e->key, ':');
3045
3046             if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
3047                 scale = e->value;
3048             else if (ret < 0)
3049                 exit_program(1);
3050         }
3051         if (scale)
3052             ist->ts_scale = strtod(scale, NULL);
3053
3054         ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
3055
3056         switch (dec->codec_type) {
3057         case AVMEDIA_TYPE_AUDIO:
3058             if(!ist->dec)
3059                 ist->dec = avcodec_find_decoder(dec->codec_id);
3060             if(audio_disable)
3061                 st->discard= AVDISCARD_ALL;
3062             break;
3063         case AVMEDIA_TYPE_VIDEO:
3064             if(!ist->dec)
3065                 ist->dec = avcodec_find_decoder(dec->codec_id);
3066             rfps      = ic->streams[i]->r_frame_rate.num;
3067             rfps_base = ic->streams[i]->r_frame_rate.den;
3068             if (dec->lowres) {
3069                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3070             }
3071             if(me_threshold)
3072                 dec->debug |= FF_DEBUG_MV;
3073
3074             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3075
3076                 if (verbose >= 0)
3077                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3078                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3079
3080                     (float)rfps / rfps_base, rfps, rfps_base);
3081             }
3082
3083             if(video_disable)
3084                 st->discard= AVDISCARD_ALL;
3085             else if(video_discard)
3086                 st->discard= video_discard;
3087             break;
3088         case AVMEDIA_TYPE_DATA:
3089             break;
3090         case AVMEDIA_TYPE_SUBTITLE:
3091             if(!ist->dec)
3092                 ist->dec = avcodec_find_decoder(dec->codec_id);
3093             if(subtitle_disable)
3094                 st->discard = AVDISCARD_ALL;
3095             break;
3096         case AVMEDIA_TYPE_ATTACHMENT:
3097         case AVMEDIA_TYPE_UNKNOWN:
3098             break;
3099         default:
3100             abort();
3101         }
3102     }
3103 }
3104
3105 static int opt_input_file(const char *opt, const char *filename)
3106 {
3107     AVFormatContext *ic;
3108     AVInputFormat *file_iformat = NULL;
3109     int err, i, ret;
3110     int64_t timestamp;
3111     uint8_t buf[128];
3112     AVDictionary **opts;
3113     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3114
3115     if (last_asked_format) {
3116         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3117             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3118             exit_program(1);
3119         }
3120         last_asked_format = NULL;
3121     }
3122
3123     if (!strcmp(filename, "-"))
3124         filename = "pipe:";
3125
3126     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3127                     !strcmp(filename, "/dev/stdin");
3128
3129     /* get default parameters from command line */
3130     ic = avformat_alloc_context();
3131     if (!ic) {
3132         print_error(filename, AVERROR(ENOMEM));
3133         exit_program(1);
3134     }
3135     if (audio_sample_rate) {
3136         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3137         av_dict_set(&format_opts, "sample_rate", buf, 0);
3138     }
3139     if (audio_channels) {
3140         snprintf(buf, sizeof(buf), "%d", audio_channels);
3141         av_dict_set(&format_opts, "channels", buf, 0);
3142     }
3143     if (frame_rate.num) {
3144         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3145         av_dict_set(&format_opts, "framerate", buf, 0);
3146     }
3147     if (frame_width && frame_height) {
3148         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3149         av_dict_set(&format_opts, "video_size", buf, 0);
3150     }
3151     if (frame_pix_fmt != PIX_FMT_NONE)
3152         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3153
3154     ic->flags |= AVFMT_FLAG_NONBLOCK;
3155
3156     if (loop_input) {
3157         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3158         ic->loop_input = loop_input;
3159     }
3160
3161     /* open the input file with generic libav function */
3162     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3163     if (err < 0) {
3164         print_error(filename, err);
3165         exit_program(1);
3166     }
3167     assert_avoptions(format_opts);
3168
3169     if(opt_programid) {
3170         int i, j;
3171         int found=0;
3172         for(i=0; i<ic->nb_streams; i++){
3173             ic->streams[i]->discard= AVDISCARD_ALL;
3174         }
3175         for(i=0; i<ic->nb_programs; i++){
3176             AVProgram *p= ic->programs[i];
3177             if(p->id != opt_programid){
3178                 p->discard = AVDISCARD_ALL;
3179             }else{
3180                 found=1;
3181                 for(j=0; j<p->nb_stream_indexes; j++){
3182                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3183                 }
3184             }
3185         }
3186         if(!found){
3187             fprintf(stderr, "Specified program id not found\n");
3188             exit_program(1);
3189         }
3190         opt_programid=0;
3191     }
3192
3193     /* apply forced codec ids */
3194     for (i = 0; i < ic->nb_streams; i++)
3195         choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3196
3197     /* Set AVCodecContext options for avformat_find_stream_info */
3198     opts = setup_find_stream_info_opts(ic, codec_opts);
3199     orig_nb_streams = ic->nb_streams;
3200
3201     /* If not enough info to get the stream parameters, we decode the
3202        first frames to get it. (used in mpeg case for example) */
3203     ret = avformat_find_stream_info(ic, opts);
3204     if (ret < 0 && verbose >= 0) {
3205         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3206         av_close_input_file(ic);
3207         exit_program(1);
3208     }
3209
3210     timestamp = start_time;
3211     /* add the stream start time */
3212     if (ic->start_time != AV_NOPTS_VALUE)
3213         timestamp += ic->start_time;
3214
3215     /* if seeking requested, we execute it */
3216     if (start_time != 0) {
3217         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3218         if (ret < 0) {
3219             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3220                     filename, (double)timestamp / AV_TIME_BASE);
3221         }
3222         /* reset seek info */
3223         start_time = 0;
3224     }
3225
3226     /* update the current parameters so that they match the one of the input stream */
3227     add_input_streams(ic);
3228
3229     /* dump the file content */
3230     if (verbose >= 0)
3231         av_dump_format(ic, nb_input_files, filename, 0);
3232
3233     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3234     input_files[nb_input_files - 1].ctx        = ic;
3235     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3236     input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);
3237     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3238
3239     top_field_first = -1;
3240     frame_rate    = (AVRational){0, 0};
3241     frame_pix_fmt = PIX_FMT_NONE;
3242     frame_height = 0;
3243     frame_width  = 0;
3244     audio_sample_rate = 0;
3245     audio_channels    = 0;
3246     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3247     av_dict_free(&ts_scale);
3248
3249     for (i = 0; i < orig_nb_streams; i++)
3250         av_dict_free(&opts[i]);
3251     av_freep(&opts);
3252     av_dict_free(&codec_names);
3253     uninit_opts();
3254     init_opts();
3255     return 0;
3256 }
3257
3258 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3259                                     AVCodecContext *avctx)
3260 {
3261     char *p;
3262     int n = 1, i;
3263     int64_t t;
3264
3265     for (p = kf; *p; p++)
3266         if (*p == ',')
3267             n++;
3268     ost->forced_kf_count = n;
3269     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3270     if (!ost->forced_kf_pts) {
3271         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3272         exit_program(1);
3273     }
3274     for (i = 0; i < n; i++) {
3275         p = i ? strchr(p, ',') + 1 : kf;
3276         t = parse_time_or_die("force_key_frames", p, 1);
3277         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3278     }
3279 }
3280
3281 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3282 {
3283     OutputStream *ost;
3284     AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3285     int idx      = oc->nb_streams - 1;
3286
3287     if (!st) {
3288         av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3289         exit_program(1);
3290     }
3291
3292     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3293                                 nb_output_streams + 1);
3294     ost = &output_streams[nb_output_streams - 1];
3295     ost->file_index = nb_output_files;
3296     ost->index = idx;
3297     ost->st    = st;
3298     st->codec->codec_type = type;
3299     ost->enc = choose_codec(oc, st, type, codec_names);
3300     if (ost->enc) {
3301         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3302     }
3303
3304     avcodec_get_context_defaults3(st->codec, ost->enc);
3305     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3306
3307     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3308     return ost;
3309 }
3310
3311 static OutputStream *new_video_stream(AVFormatContext *oc)
3312 {
3313     AVStream *st;
3314     OutputStream *ost;
3315     AVCodecContext *video_enc;
3316
3317     ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3318     st  = ost->st;
3319     if (!st->stream_copy) {
3320         ost->frame_aspect_ratio = frame_aspect_ratio;
3321         frame_aspect_ratio = 0;
3322 #if CONFIG_AVFILTER
3323         ost->avfilter = vfilters;
3324         vfilters = NULL;
3325 #endif
3326     }
3327
3328     ost->bitstream_filters = video_bitstream_filters;
3329     video_bitstream_filters= NULL;
3330
3331     st->codec->thread_count= thread_count;
3332
3333     video_enc = st->codec;
3334
3335     if(video_codec_tag)
3336         video_enc->codec_tag= video_codec_tag;
3337
3338     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3339         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3340     }
3341
3342     if (st->stream_copy) {
3343         video_enc->sample_aspect_ratio =
3344         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3345     } else {
3346         const char *p;
3347         int i;
3348
3349         if (frame_rate.num)
3350             ost->frame_rate = frame_rate;
3351
3352         video_enc->width = frame_width;
3353         video_enc->height = frame_height;
3354         video_enc->pix_fmt = frame_pix_fmt;
3355         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3356         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3357
3358         if (intra_only)
3359             video_enc->gop_size = 0;
3360         if (video_qscale || same_quant) {
3361             video_enc->flags |= CODEC_FLAG_QSCALE;
3362             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3363         }
3364
3365         if(intra_matrix)
3366             video_enc->intra_matrix = intra_matrix;
3367         if(inter_matrix)
3368             video_enc->inter_matrix = inter_matrix;
3369
3370         p= video_rc_override_string;
3371         for(i=0; p; i++){
3372             int start, end, q;
3373             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3374             if(e!=3){
3375                 fprintf(stderr, "error parsing rc_override\n");
3376                 exit_program(1);
3377             }
3378             video_enc->rc_override=
3379                 av_realloc(video_enc->rc_override,
3380                            sizeof(RcOverride)*(i+1));
3381             video_enc->rc_override[i].start_frame= start;
3382             video_enc->rc_override[i].end_frame  = end;
3383             if(q>0){
3384                 video_enc->rc_override[i].qscale= q;
3385                 video_enc->rc_override[i].quality_factor= 1.0;
3386             }
3387             else{
3388                 video_enc->rc_override[i].qscale= 0;
3389                 video_enc->rc_override[i].quality_factor= -q/100.0;
3390             }
3391             p= strchr(p, '/');
3392             if(p) p++;
3393         }
3394         video_enc->rc_override_count=i;
3395         if (!video_enc->rc_initial_buffer_occupancy)
3396             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3397         video_enc->me_threshold= me_threshold;
3398         video_enc->intra_dc_precision= intra_dc_precision - 8;
3399
3400         if (do_psnr)
3401             video_enc->flags|= CODEC_FLAG_PSNR;
3402
3403         /* two pass mode */
3404         if (do_pass) {
3405             if (do_pass == 1) {
3406                 video_enc->flags |= CODEC_FLAG_PASS1;
3407             } else {
3408                 video_enc->flags |= CODEC_FLAG_PASS2;
3409             }
3410         }
3411
3412         if (forced_key_frames)
3413             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3414     }
3415     if (video_language) {
3416         av_dict_set(&st->metadata, "language", video_language, 0);
3417         av_freep(&video_language);
3418     }
3419
3420     /* reset some key parameters */
3421     video_disable = 0;
3422     av_freep(&forced_key_frames);
3423     frame_pix_fmt = PIX_FMT_NONE;
3424     return ost;
3425 }
3426
3427 static OutputStream *new_audio_stream(AVFormatContext *oc)
3428 {
3429     AVStream *st;
3430     OutputStream *ost;
3431     AVCodecContext *audio_enc;
3432
3433     ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3434     st  = ost->st;
3435
3436     ost->bitstream_filters = audio_bitstream_filters;
3437     audio_bitstream_filters= NULL;
3438
3439     st->codec->thread_count= thread_count;
3440
3441     audio_enc = st->codec;
3442     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3443
3444     if(audio_codec_tag)
3445         audio_enc->codec_tag= audio_codec_tag;
3446
3447     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3448         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3449     }
3450     if (!st->stream_copy) {
3451         if (audio_qscale > QSCALE_NONE) {
3452             audio_enc->flags |= CODEC_FLAG_QSCALE;
3453             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3454         }
3455         if (audio_channels)
3456             audio_enc->channels = audio_channels;
3457         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3458             audio_enc->sample_fmt = audio_sample_fmt;
3459         if (audio_sample_rate)
3460             audio_enc->sample_rate = audio_sample_rate;
3461     }
3462     if (audio_language) {
3463         av_dict_set(&st->metadata, "language", audio_language, 0);
3464         av_freep(&audio_language);
3465     }
3466
3467     /* reset some key parameters */
3468     audio_disable = 0;
3469
3470     return ost;
3471 }
3472
3473 static OutputStream *new_data_stream(AVFormatContext *oc)
3474 {
3475     AVStream *st;
3476     OutputStream *ost;
3477     AVCodecContext *data_enc;
3478
3479     ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3480     st  = ost->st;
3481     data_enc = st->codec;
3482     if (!st->stream_copy) {
3483         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3484         exit_program(1);
3485     }
3486
3487     if (data_codec_tag)
3488         data_enc->codec_tag= data_codec_tag;
3489
3490     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3491         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3492     }
3493
3494     data_disable = 0;
3495     return ost;
3496 }
3497
3498 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3499 {
3500     AVStream *st;
3501     OutputStream *ost;
3502     AVCodecContext *subtitle_enc;
3503
3504     ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3505     st  = ost->st;
3506     subtitle_enc = st->codec;
3507
3508     ost->bitstream_filters = subtitle_bitstream_filters;
3509     subtitle_bitstream_filters= NULL;
3510
3511     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3512
3513     if(subtitle_codec_tag)
3514         subtitle_enc->codec_tag= subtitle_codec_tag;
3515
3516     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3517         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3518     }
3519
3520     if (subtitle_language) {
3521         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3522         av_freep(&subtitle_language);
3523     }
3524
3525     subtitle_disable = 0;
3526     return ost;
3527 }
3528
3529 /* arg format is "output-stream-index:streamid-value". */
3530 static int opt_streamid(const char *opt, const char *arg)
3531 {
3532     int idx;
3533     char *p;
3534     char idx_str[16];
3535
3536     av_strlcpy(idx_str, arg, sizeof(idx_str));
3537     p = strchr(idx_str, ':');
3538     if (!p) {
3539         fprintf(stderr,
3540                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3541                 arg, opt);
3542         exit_program(1);
3543     }
3544     *p++ = '\0';
3545     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3546     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3547     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3548     return 0;
3549 }
3550 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
3551 {
3552     int i, err;
3553     AVFormatContext *ic = NULL;
3554
3555     err = avformat_open_input(&ic, filename, NULL, NULL);
3556     if (err < 0)
3557         return err;
3558     /* copy stream format */
3559     for(i=0;i<ic->nb_streams;i++) {
3560         AVStream *st;
3561         OutputStream *ost;
3562         AVCodec *codec;
3563
3564         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3565         ost   = new_output_stream(s, codec->type);
3566         st    = ost->st;
3567
3568         // FIXME: a more elegant solution is needed
3569         memcpy(st, ic->streams[i], sizeof(AVStream));
3570         st->info = av_malloc(sizeof(*st->info));
3571         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3572         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3573
3574         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3575             choose_sample_fmt(st, codec);
3576         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3577             choose_pixel_fmt(st, codec);
3578     }
3579
3580     av_close_input_file(ic);
3581     return 0;
3582 }
3583
3584
3585 static int copy_chapters(int infile, int outfile)
3586 {
3587     AVFormatContext *is = input_files[infile].ctx;
3588     AVFormatContext *os = output_files[outfile].ctx;
3589     int i;
3590
3591     for (i = 0; i < is->nb_chapters; i++) {
3592         AVChapter *in_ch = is->chapters[i], *out_ch;
3593         int64_t ts_off   = av_rescale_q(start_time - input_files[infile].ts_offset,
3594                                       AV_TIME_BASE_Q, in_ch->time_base);
3595         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
3596                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3597
3598
3599         if (in_ch->end < ts_off)
3600             continue;
3601         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3602             break;
3603
3604         out_ch = av_mallocz(sizeof(AVChapter));
3605         if (!out_ch)
3606             return AVERROR(ENOMEM);
3607
3608         out_ch->id        = in_ch->id;
3609         out_ch->time_base = in_ch->time_base;
3610         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3611         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3612
3613         if (metadata_chapters_autocopy)
3614             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3615
3616         os->nb_chapters++;
3617         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3618         if (!os->chapters)
3619             return AVERROR(ENOMEM);
3620         os->chapters[os->nb_chapters - 1] = out_ch;
3621     }
3622     return 0;
3623 }
3624
3625 static int opt_output_file(const char *opt, const char *filename)
3626 {
3627     AVFormatContext *oc;
3628     int i, err;
3629     AVOutputFormat *file_oformat;
3630     OutputStream *ost;
3631     InputStream  *ist;
3632
3633     if (!strcmp(filename, "-"))
3634         filename = "pipe:";
3635
3636     err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3637     last_asked_format = NULL;
3638     if (!oc) {
3639         print_error(filename, err);
3640         exit_program(1);
3641     }
3642     file_oformat= oc->oformat;
3643
3644     if (!strcmp(file_oformat->name, "ffm") &&
3645         av_strstart(filename, "http:", NULL)) {
3646         /* special case for files sent to ffserver: we get the stream
3647            parameters from ffserver */
3648         int err = read_ffserver_streams(oc, filename);
3649         if (err < 0) {
3650             print_error(filename, err);
3651             exit_program(1);
3652         }
3653     } else if (!nb_stream_maps) {
3654         /* pick the "best" stream of each type */
3655 #define NEW_STREAM(type, index)\
3656         if (index >= 0) {\
3657             ost = new_ ## type ## _stream(oc);\
3658             ost->source_index = index;\
3659             ost->sync_ist     = &input_streams[index];\
3660             input_streams[index].discard = 0;\
3661         }
3662
3663         /* video: highest resolution */
3664         if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3665             int area = 0, idx = -1;
3666             for (i = 0; i < nb_input_streams; i++) {
3667                 ist = &input_streams[i];
3668                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3669                     ist->st->codec->width * ist->st->codec->height > area) {
3670                     area = ist->st->codec->width * ist->st->codec->height;
3671                     idx = i;
3672                 }
3673             }
3674             NEW_STREAM(video, idx);
3675         }
3676
3677         /* audio: most channels */
3678         if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3679             int channels = 0, idx = -1;
3680             for (i = 0; i < nb_input_streams; i++) {
3681                 ist = &input_streams[i];
3682                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3683                     ist->st->codec->channels > channels) {
3684                     channels = ist->st->codec->channels;
3685                     idx = i;
3686                 }
3687             }
3688             NEW_STREAM(audio, idx);
3689         }
3690
3691         /* subtitles: pick first */
3692         if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3693             for (i = 0; i < nb_input_streams; i++)
3694                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3695                     NEW_STREAM(subtitle, i);
3696                     break;
3697                 }
3698         }
3699         /* do something with data? */
3700     } else {
3701         for (i = 0; i < nb_stream_maps; i++) {
3702             StreamMap *map = &stream_maps[i];
3703
3704             if (map->disabled)
3705                 continue;
3706
3707             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3708             switch (ist->st->codec->codec_type) {
3709             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(oc);    break;
3710             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(oc);    break;
3711             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3712             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(oc);     break;
3713             default:
3714                 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3715                        map->file_index, map->stream_index);
3716                 exit_program(1);
3717             }
3718
3719             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3720             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3721                                            map->sync_stream_index];
3722             ist->discard = 0;
3723         }
3724     }
3725
3726     av_dict_copy(&oc->metadata, metadata, 0);
3727     av_dict_free(&metadata);
3728
3729
3730     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3731     output_files[nb_output_files - 1].ctx       = oc;
3732     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3733     output_files[nb_output_files - 1].recording_time = recording_time;
3734     output_files[nb_output_files - 1].start_time     = start_time;
3735     output_files[nb_output_files - 1].limit_filesize = limit_filesize;
3736     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3737
3738     /* check filename in case of an image number is expected */
3739     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3740         if (!av_filename_number_test(oc->filename)) {
3741             print_error(oc->filename, AVERROR(EINVAL));
3742             exit_program(1);
3743         }
3744     }
3745
3746     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3747         /* test if it already exists to avoid loosing precious files */
3748         if (!file_overwrite &&
3749             (strchr(filename, ':') == NULL ||
3750              filename[1] == ':' ||
3751              av_strstart(filename, "file:", NULL))) {
3752             if (avio_check(filename, 0) == 0) {
3753                 if (!using_stdin) {
3754                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3755                     fflush(stderr);
3756                     if (!read_yesno()) {
3757                         fprintf(stderr, "Not overwriting - exiting\n");
3758                         exit_program(1);
3759                     }
3760                 }
3761                 else {
3762                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3763                     exit_program(1);
3764                 }
3765             }
3766         }
3767
3768         /* open the file */
3769         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3770             print_error(filename, err);
3771             exit_program(1);
3772         }
3773     }
3774
3775     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3776     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3777
3778     if (loop_output >= 0) {
3779         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3780         oc->loop_output = loop_output;
3781     }
3782
3783     /* copy chapters */
3784     if (chapters_input_file >= nb_input_files) {
3785         if (chapters_input_file == INT_MAX) {
3786             /* copy chapters from the first input file that has them*/
3787             chapters_input_file = -1;
3788             for (i = 0; i < nb_input_files; i++)
3789                 if (input_files[i].ctx->nb_chapters) {
3790                     chapters_input_file = i;
3791                     break;
3792                 }
3793         } else {
3794             av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3795                    chapters_input_file);
3796             exit_program(1);
3797         }
3798     }
3799     if (chapters_input_file >= 0)
3800         copy_chapters(chapters_input_file, nb_output_files - 1);
3801
3802     /* copy metadata */
3803     for (i = 0; i < nb_meta_data_maps; i++) {
3804         AVFormatContext *files[2];
3805         AVDictionary    **meta[2];
3806         int j;
3807
3808 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3809         if ((index) < 0 || (index) >= (nb_elems)) {\
3810             av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3811                      (desc), (index));\
3812             exit_program(1);\
3813         }
3814
3815         int in_file_index = meta_data_maps[i][1].file;
3816         if (in_file_index < 0)
3817             continue;
3818         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3819
3820         files[0] = oc;
3821         files[1] = input_files[in_file_index].ctx;
3822
3823         for (j = 0; j < 2; j++) {
3824             MetadataMap *map = &meta_data_maps[i][j];
3825
3826             switch (map->type) {
3827             case 'g':
3828                 meta[j] = &files[j]->metadata;
3829                 break;
3830             case 's':
3831                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3832                 meta[j] = &files[j]->streams[map->index]->metadata;
3833                 break;
3834             case 'c':
3835                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3836                 meta[j] = &files[j]->chapters[map->index]->metadata;
3837                 break;
3838             case 'p':
3839                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3840                 meta[j] = &files[j]->programs[map->index]->metadata;
3841                 break;
3842             }
3843         }
3844
3845         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3846     }
3847
3848     /* copy global metadata by default */
3849     if (metadata_global_autocopy && nb_input_files)
3850         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3851                      AV_DICT_DONT_OVERWRITE);
3852     if (metadata_streams_autocopy)
3853         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3854             InputStream *ist = &input_streams[output_streams[i].source_index];
3855             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3856         }
3857
3858     frame_rate    = (AVRational){0, 0};
3859     frame_width   = 0;
3860     frame_height  = 0;
3861     audio_sample_rate = 0;
3862     audio_channels    = 0;
3863     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3864     chapters_input_file = INT_MAX;
3865     recording_time = INT64_MAX;
3866     start_time     = 0;
3867     limit_filesize = UINT64_MAX;
3868
3869     av_freep(&meta_data_maps);
3870     nb_meta_data_maps = 0;
3871     metadata_global_autocopy   = 1;
3872     metadata_streams_autocopy  = 1;
3873     metadata_chapters_autocopy = 1;
3874     av_freep(&stream_maps);
3875     nb_stream_maps = 0;
3876     av_freep(&streamid_map);
3877     nb_streamid_map = 0;
3878
3879     av_dict_free(&codec_names);
3880
3881     av_freep(&forced_key_frames);
3882     uninit_opts();
3883     init_opts();
3884     return 0;
3885 }
3886
3887 /* same option as mencoder */
3888 static int opt_pass(const char *opt, const char *arg)
3889 {
3890     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3891     return 0;
3892 }
3893
3894 static int64_t getutime(void)
3895 {
3896 #if HAVE_GETRUSAGE
3897     struct rusage rusage;
3898
3899     getrusage(RUSAGE_SELF, &rusage);
3900     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3901 #elif HAVE_GETPROCESSTIMES
3902     HANDLE proc;
3903     FILETIME c, e, k, u;
3904     proc = GetCurrentProcess();
3905     GetProcessTimes(proc, &c, &e, &k, &u);
3906     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3907 #else
3908     return av_gettime();
3909 #endif
3910 }
3911
3912 static int64_t getmaxrss(void)
3913 {
3914 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3915     struct rusage rusage;
3916     getrusage(RUSAGE_SELF, &rusage);
3917     return (int64_t)rusage.ru_maxrss * 1024;
3918 #elif HAVE_GETPROCESSMEMORYINFO
3919     HANDLE proc;
3920     PROCESS_MEMORY_COUNTERS memcounters;
3921     proc = GetCurrentProcess();
3922     memcounters.cb = sizeof(memcounters);
3923     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3924     return memcounters.PeakPagefileUsage;
3925 #else
3926     return 0;
3927 #endif
3928 }
3929
3930 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3931 {
3932     int i;
3933     const char *p = str;
3934     for(i = 0;; i++) {
3935         dest[i] = atoi(p);
3936         if(i == 63)
3937             break;
3938         p = strchr(p, ',');
3939         if(!p) {
3940             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3941             exit_program(1);
3942         }
3943         p++;
3944     }
3945 }
3946
3947 static int opt_inter_matrix(const char *opt, const char *arg)
3948 {
3949     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3950     parse_matrix_coeffs(inter_matrix, arg);
3951     return 0;
3952 }
3953
3954 static int opt_intra_matrix(const char *opt, const char *arg)
3955 {
3956     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3957     parse_matrix_coeffs(intra_matrix, arg);
3958     return 0;
3959 }
3960
3961 static void show_usage(void)
3962 {
3963     printf("Hyper fast Audio and Video encoder\n");
3964     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3965     printf("\n");
3966 }
3967
3968 static int opt_help(const char *opt, const char *arg)
3969 {
3970     AVCodec *c;
3971     AVOutputFormat *oformat = NULL;
3972     AVInputFormat  *iformat = NULL;
3973
3974     av_log_set_callback(log_callback_help);
3975     show_usage();
3976     show_help_options(options, "Main options:\n",
3977                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3978     show_help_options(options, "\nAdvanced options:\n",
3979                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3980                       OPT_EXPERT);
3981     show_help_options(options, "\nVideo options:\n",
3982                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3983                       OPT_VIDEO);
3984     show_help_options(options, "\nAdvanced Video options:\n",
3985                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3986                       OPT_VIDEO | OPT_EXPERT);
3987     show_help_options(options, "\nAudio options:\n",
3988                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3989                       OPT_AUDIO);
3990     show_help_options(options, "\nAdvanced Audio options:\n",
3991                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3992                       OPT_AUDIO | OPT_EXPERT);
3993     show_help_options(options, "\nSubtitle options:\n",
3994                       OPT_SUBTITLE | OPT_GRAB,
3995                       OPT_SUBTITLE);
3996     show_help_options(options, "\nAudio/Video grab options:\n",
3997                       OPT_GRAB,
3998                       OPT_GRAB);
3999     printf("\n");
4000     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4001     printf("\n");
4002
4003     /* individual codec options */
4004     c = NULL;
4005     while ((c = av_codec_next(c))) {
4006         if (c->priv_class) {
4007             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4008             printf("\n");
4009         }
4010     }
4011
4012     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4013     printf("\n");
4014
4015     /* individual muxer options */
4016     while ((oformat = av_oformat_next(oformat))) {
4017         if (oformat->priv_class) {
4018             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4019             printf("\n");
4020         }
4021     }
4022
4023     /* individual demuxer options */
4024     while ((iformat = av_iformat_next(iformat))) {
4025         if (iformat->priv_class) {
4026             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4027             printf("\n");
4028         }
4029     }
4030
4031     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4032     return 0;
4033 }
4034
4035 static int opt_target(const char *opt, const char *arg)
4036 {
4037     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4038     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4039
4040     if(!strncmp(arg, "pal-", 4)) {
4041         norm = PAL;
4042         arg += 4;
4043     } else if(!strncmp(arg, "ntsc-", 5)) {
4044         norm = NTSC;
4045         arg += 5;
4046     } else if(!strncmp(arg, "film-", 5)) {
4047         norm = FILM;
4048         arg += 5;
4049     } else {
4050         int fr;
4051         /* Calculate FR via float to avoid int overflow */
4052         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4053         if(fr == 25000) {
4054             norm = PAL;
4055         } else if((fr == 29970) || (fr == 23976)) {
4056             norm = NTSC;
4057         } else {
4058             /* Try to determine PAL/NTSC by peeking in the input files */
4059             if(nb_input_files) {
4060                 int i, j;
4061                 for (j = 0; j < nb_input_files; j++) {
4062                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4063                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4064                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4065                             continue;
4066                         fr = c->time_base.den * 1000 / c->time_base.num;
4067                         if(fr == 25000) {
4068                             norm = PAL;
4069                             break;
4070                         } else if((fr == 29970) || (fr == 23976)) {
4071                             norm = NTSC;
4072                             break;
4073                         }
4074                     }
4075                     if(norm != UNKNOWN)
4076                         break;
4077                 }
4078             }
4079         }
4080         if(verbose > 0 && norm != UNKNOWN)
4081             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4082     }
4083
4084     if(norm == UNKNOWN) {
4085         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4086         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4087         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4088         exit_program(1);
4089     }
4090
4091     if(!strcmp(arg, "vcd")) {
4092         opt_codec("c:v", "mpeg1video");
4093         opt_codec("c:a", "mp2");
4094         opt_format("f", "vcd");
4095
4096         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4097         opt_frame_rate("r", frame_rates[norm]);
4098         opt_default("g", norm == PAL ? "15" : "18");
4099
4100         opt_default("b", "1150000");
4101         opt_default("maxrate", "1150000");
4102         opt_default("minrate", "1150000");
4103         opt_default("bufsize", "327680"); // 40*1024*8;
4104
4105         opt_default("b:a", "224000");
4106         audio_sample_rate = 44100;
4107         audio_channels = 2;
4108
4109         opt_default("packetsize", "2324");
4110         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4111
4112         /* We have to offset the PTS, so that it is consistent with the SCR.
4113            SCR starts at 36000, but the first two packs contain only padding
4114            and the first pack from the other stream, respectively, may also have
4115            been written before.
4116            So the real data starts at SCR 36000+3*1200. */
4117         mux_preload= (36000+3*1200) / 90000.0; //0.44
4118     } else if(!strcmp(arg, "svcd")) {
4119
4120         opt_codec("c:v", "mpeg2video");
4121         opt_codec("c:a", "mp2");
4122         opt_format("f", "svcd");
4123
4124         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4125         opt_frame_rate("r", frame_rates[norm]);
4126         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4127         opt_default("g", norm == PAL ? "15" : "18");
4128
4129         opt_default("b", "2040000");
4130         opt_default("maxrate", "2516000");
4131         opt_default("minrate", "0"); //1145000;
4132         opt_default("bufsize", "1835008"); //224*1024*8;
4133         opt_default("flags", "+scan_offset");
4134
4135
4136         opt_default("b:a", "224000");
4137         audio_sample_rate = 44100;
4138
4139         opt_default("packetsize", "2324");
4140
4141     } else if(!strcmp(arg, "dvd")) {
4142
4143         opt_codec("c:v", "mpeg2video");
4144         opt_codec("c:a", "ac3");
4145         opt_format("f", "dvd");
4146
4147         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4148         opt_frame_rate("r", frame_rates[norm]);
4149         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4150         opt_default("g", norm == PAL ? "15" : "18");
4151
4152         opt_default("b", "6000000");
4153         opt_default("maxrate", "9000000");
4154         opt_default("minrate", "0"); //1500000;
4155         opt_default("bufsize", "1835008"); //224*1024*8;
4156
4157         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4158         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4159
4160         opt_default("b:a", "448000");
4161         audio_sample_rate = 48000;
4162
4163     } else if(!strncmp(arg, "dv", 2)) {
4164
4165         opt_format("f", "dv");
4166
4167         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4168         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4169                           norm == PAL ? "yuv420p" : "yuv411p");
4170         opt_frame_rate("r", frame_rates[norm]);
4171
4172         audio_sample_rate = 48000;
4173         audio_channels = 2;
4174
4175     } else {
4176         fprintf(stderr, "Unknown target: %s\n", arg);
4177         return AVERROR(EINVAL);
4178     }
4179     return 0;
4180 }
4181
4182 static int opt_vstats_file(const char *opt, const char *arg)
4183 {
4184     av_free (vstats_filename);
4185     vstats_filename=av_strdup (arg);
4186     return 0;
4187 }
4188
4189 static int opt_vstats(const char *opt, const char *arg)
4190 {
4191     char filename[40];
4192     time_t today2 = time(NULL);
4193     struct tm *today = localtime(&today2);
4194
4195     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4196              today->tm_sec);
4197     return opt_vstats_file(opt, filename);
4198 }
4199
4200 static int opt_bsf(const char *opt, const char *arg)
4201 {
4202     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4203     AVBitStreamFilterContext **bsfp;
4204
4205     if(!bsfc){
4206         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4207         exit_program(1);
4208     }
4209
4210     bsfp= *opt == 'v' ? &video_bitstream_filters :
4211           *opt == 'a' ? &audio_bitstream_filters :
4212                         &subtitle_bitstream_filters;
4213     while(*bsfp)
4214         bsfp= &(*bsfp)->next;
4215
4216     *bsfp= bsfc;
4217
4218     return 0;
4219 }
4220
4221 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4222 {
4223 }
4224
4225 static int opt_passlogfile(const char *opt, const char *arg)
4226 {
4227     pass_logfilename_prefix = arg;
4228 #if CONFIG_LIBX264_ENCODER
4229     return opt_default("passlogfile", arg);
4230 #else
4231     return 0;
4232 #endif
4233 }
4234
4235 static const OptionDef options[] = {
4236     /* main options */
4237 #include "cmdutils_common_opts.h"
4238     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4239     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4240     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4241     { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4242     { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4243     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4244     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4245       "outfile[,metadata]:infile[,metadata]" },
4246     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4247       "outfile[,metadata]:infile[,metadata]" },
4248     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file},  "set chapters mapping", "input_file_index" },
4249     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4250     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4251     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4252     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4253     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "scale" },
4254     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4255     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4256     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4257     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4258       "add timings for benchmarking" },
4259     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4260     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4261       "dump each input packet" },
4262     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4263       "when dumping packets, also dump the payload" },
4264     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4265     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4266     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4267     { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4268     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4269     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4270     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4271     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4272     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4273     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4274     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4275     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4276     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4277     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4278     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4279     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4280
4281     /* video options */
4282     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4283     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4284     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4285     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4286     { "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" },
4287     { "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" },
4288     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4289     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4290     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4291     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4292     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4293     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4294     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4295     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4296     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4297     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4298     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4299     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4300     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4301     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4302     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4303     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold",  "threshold" },
4304     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4305     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4306     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4307     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4308     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4309       "deinterlace pictures" },
4310     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4311     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4312     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4313 #if CONFIG_AVFILTER
4314     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4315 #endif
4316     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4317     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4318     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4319     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4320     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4321     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4322     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4323     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4324     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4325     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4326
4327     /* audio options */
4328     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4329     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4330     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4331     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4332     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4333     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4334     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4335     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4336     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4337     { "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" },
4338
4339     /* subtitle options */
4340     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4341     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4342     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4343     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4344
4345     /* grab options */
4346     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4347     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4348     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4349
4350     /* muxer options */
4351     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4352     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4353
4354     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4355     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4356     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4357
4358     /* data codec support */
4359     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4360
4361     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4362     { NULL, },
4363 };
4364
4365 int main(int argc, char **argv)
4366 {
4367     int64_t ti;
4368
4369     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4370
4371     if(argc>1 && !strcmp(argv[1], "-d")){
4372         run_as_daemon=1;
4373         verbose=-1;
4374         av_log_set_callback(log_callback_null);
4375         argc--;
4376         argv++;
4377     }
4378
4379     avcodec_register_all();
4380 #if CONFIG_AVDEVICE
4381     avdevice_register_all();
4382 #endif
4383 #if CONFIG_AVFILTER
4384     avfilter_register_all();
4385 #endif
4386     av_register_all();
4387
4388 #if HAVE_ISATTY
4389     if(isatty(STDIN_FILENO))
4390         avio_set_interrupt_cb(decode_interrupt_cb);
4391 #endif
4392
4393     init_opts();
4394
4395     if(verbose>=0)
4396         show_banner();
4397
4398     /* parse options */
4399     parse_options(argc, argv, options, opt_output_file);
4400
4401     if(nb_output_files <= 0 && nb_input_files == 0) {
4402         show_usage();
4403         fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4404         exit_program(1);
4405     }
4406
4407     /* file converter / grab */
4408     if (nb_output_files <= 0) {
4409         fprintf(stderr, "At least one output file must be specified\n");
4410         exit_program(1);
4411     }
4412
4413     if (nb_input_files == 0) {
4414         fprintf(stderr, "At least one input file must be specified\n");
4415         exit_program(1);
4416     }
4417
4418     ti = getutime();
4419     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4420         exit_program(1);
4421     ti = getutime() - ti;
4422     if (do_benchmark) {
4423         int maxrss = getmaxrss() / 1024;
4424         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4425     }
4426
4427     return exit_program(0);
4428 }