ffmpeg.c

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