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

   1 /*
   2  * Copyright (c) 2000-2003 Fabrice Bellard
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /**
  22  * @file
  23  * multimedia converter based on the FFmpeg libraries
  24  */
  25
  26 #include "config.h"
  27 #include <ctype.h>
  28 #include <string.h>
  29 #include <math.h>
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #include <signal.h>
  33 #include <limits.h>
  34 #if HAVE_ISATTY
  35 #include <unistd.h>
  36 #endif
  37 #include "libavformat/avformat.h"
  38 #include "libavdevice/avdevice.h"
  39 #include "libswscale/swscale.h"
  40 #include "libswresample/swresample.h"
  41 #include "libavutil/opt.h"
  42 #include "libavutil/audioconvert.h"
  43 #include "libavutil/parseutils.h"
  44 #include "libavutil/samplefmt.h"
  45 #include "libavutil/colorspace.h"
  46 #include "libavutil/fifo.h"
  47 #include "libavutil/intreadwrite.h"
  48 #include "libavutil/dict.h"
  49 #include "libavutil/mathematics.h"
  50 #include "libavutil/pixdesc.h"
  51 #include "libavutil/avstring.h"
  52 #include "libavutil/libm.h"
  53 #include "libavutil/imgutils.h"
  54 #include "libavutil/timestamp.h"
  55 #include "libavutil/bprint.h"
  56 #include "libavutil/time.h"
  57 #include "libavformat/os_support.h"
  58
  59 #include "libavformat/ffm.h" // not public API
  60
  61 # include "libavfilter/avcodec.h"
  62 # include "libavfilter/avfilter.h"
  63 # include "libavfilter/avfiltergraph.h"
  64 # include "libavfilter/buffersrc.h"
  65 # include "libavfilter/buffersink.h"
  66
  67 #if HAVE_SYS_RESOURCE_H
  68 #include <sys/types.h>
  69 #include <sys/resource.h>
  70 #elif HAVE_GETPROCESSTIMES
  71 #include <windows.h>
  72 #endif
  73 #if HAVE_GETPROCESSMEMORYINFO
  74 #include <windows.h>
  75 #include <psapi.h>
  76 #endif
  77
  78 #if HAVE_SYS_SELECT_H
  79 #include <sys/select.h>
  80 #endif
  81
  82 #if HAVE_TERMIOS_H
  83 #include <fcntl.h>
  84 #include <sys/ioctl.h>
  85 #include <sys/time.h>
  86 #include <termios.h>
  87 #elif HAVE_KBHIT
  88 #include <conio.h>
  89 #endif
  90
  91 #if HAVE_PTHREADS
  92 #include <pthread.h>
  93 #endif
  94
  95 #include <time.h>
  96
  97 #include "cmdutils.h"
  98
  99 #include "libavutil/avassert.h"
 100
 101 #define VSYNC_AUTO       -1
 102 #define VSYNC_PASSTHROUGH 0
 103 #define VSYNC_CFR         1
 104 #define VSYNC_VFR         2
 105 #define VSYNC_DROP        0xff
 106
 107 const char program_name[] = "ffmpeg";
 108 const int program_birth_year = 2000;
 109
 110 /* select an input stream for an output stream */
 111 typedef struct StreamMap {
 112     int disabled;           /** 1 is this mapping is disabled by a negative map */
 113     int file_index;
 114     int stream_index;
 115     int sync_file_index;
 116     int sync_stream_index;
 117     char *linklabel;       /** name of an output link, for mapping lavfi outputs */
 118 } StreamMap;
 119
 120 typedef struct {
 121     int  file_idx,  stream_idx,  channel_idx; // input
 122     int ofile_idx, ostream_idx;               // output
 123 } AudioChannelMap;
 124
 125 static const OptionDef options[];
 126
 127 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
 128
 129 static int frame_bits_per_raw_sample = 0;
 130 static int video_discard = 0;
 131 static int same_quant = 0;
 132 static int do_deinterlace = 0;
 133 static int intra_dc_precision = 8;
 134 static int qp_hist = 0;
 135 static int intra_only = 0;
 136 static const char *video_codec_name    = NULL;
 137 static const char *audio_codec_name    = NULL;
 138 static const char *subtitle_codec_name = NULL;
 139
 140 static int file_overwrite = 0;
 141 static int no_file_overwrite = 0;
 142 static int do_benchmark = 0;
 143 static int do_benchmark_all = 0;
 144 static int do_hex_dump = 0;
 145 static int do_pkt_dump = 0;
 146 static int do_psnr = 0;
 147 static int do_pass = 0;
 148 static const char *pass_logfilename_prefix;
 149 static int video_sync_method = VSYNC_AUTO;
 150 static int audio_sync_method = 0;
 151 static float audio_drift_threshold = 0.1;
 152 static int copy_ts = 0;
 153 static int copy_tb = -1;
 154 static int opt_shortest = 0;
 155 static char *vstats_filename;
 156 static FILE *vstats_file;
 157
 158 static int audio_volume = 256;
 159
 160 static int exit_on_error = 0;
 161 static int stdin_interaction = 1;
 162 static int run_as_daemon  = 0;
 163 static volatile int received_nb_signals = 0;
 164 static int64_t video_size = 0;
 165 static int64_t audio_size = 0;
 166 static int64_t subtitle_size = 0;
 167 static int64_t extra_size = 0;
 168 static int nb_frames_dup = 0;
 169 static int nb_frames_drop = 0;
 170 static int input_sync;
 171
 172 static float dts_delta_threshold = 10;
 173 static float dts_error_threshold = 3600*30;
 174
 175 static int print_stats = 1;
 176 static int debug_ts = 0;
 177 static int current_time;
 178 static AVIOContext *progress_avio = NULL;
 179
 180 static uint8_t *subtitle_out;
 181
 182 #if HAVE_PTHREADS
 183 /* signal to input threads that they should exit; set by the main thread */
 184 static int transcoding_finished;
 185 #endif
 186
 187 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
 188
 189 typedef struct InputFilter {
 190     AVFilterContext    *filter;
 191     struct InputStream *ist;
 192     struct FilterGraph *graph;
 193     uint8_t            *name;
 194 } InputFilter;
 195
 196 typedef struct OutputFilter {
 197     AVFilterContext     *filter;
 198     struct OutputStream *ost;
 199     struct FilterGraph  *graph;
 200     uint8_t             *name;
 201
 202     /* temporary storage until stream maps are processed */
 203     AVFilterInOut       *out_tmp;
 204 } OutputFilter;
 205
 206 typedef struct FilterGraph {
 207     int            index;
 208     const char    *graph_desc;
 209
 210     AVFilterGraph *graph;
 211
 212     InputFilter   **inputs;
 213     int          nb_inputs;
 214     OutputFilter **outputs;
 215     int         nb_outputs;
 216 } FilterGraph;
 217
 218 typedef struct InputStream {
 219     int file_index;
 220     AVStream *st;
 221     int discard;             /* true if stream data should be discarded */
 222     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 223     AVCodec *dec;
 224     AVFrame *decoded_frame;
 225
 226     int64_t       start;     /* time when read started */
 227     /* predicted dts of the next packet read for this stream or (when there are
 228      * several frames in a packet) of the next frame in current packet */
 229     int64_t       next_dts;
 230     /* dts of the last packet read for this stream */
 231     int64_t       dts;
 232
 233     int64_t       next_pts;  /* synthetic pts for the next decode frame */
 234     int64_t       pts;       /* current pts of the decoded frame */
 235     double ts_scale;
 236     int is_start;            /* is 1 at the start and after a discontinuity */
 237     int saw_first_ts;
 238     int showed_multi_packet_warning;
 239     AVDictionary *opts;
 240     AVRational framerate;               /* framerate forced with -r */
 241     int top_field_first;
 242
 243     int resample_height;
 244     int resample_width;
 245     int resample_pix_fmt;
 246
 247     int      resample_sample_fmt;
 248     int      resample_sample_rate;
 249     int      resample_channels;
 250     uint64_t resample_channel_layout;
 251
 252     /* a pool of free buffers for decoded data */
 253     FrameBuffer *buffer_pool;
 254     int dr1;
 255
 256     /* decoded data from this stream goes into all those filters
 257      * currently video and audio only */
 258     InputFilter **filters;
 259     int        nb_filters;
 260 } InputStream;
 261
 262 typedef struct InputFile {
 263     AVFormatContext *ctx;
 264     int eof_reached;      /* true if eof reached */
 265     int ist_index;        /* index of first stream in input_streams */
 266     int64_t ts_offset;
 267     int nb_streams;       /* number of stream that ffmpeg is aware of; may be different
 268                              from ctx.nb_streams if new streams appear during av_read_frame() */
 269     int rate_emu;
 270
 271 #if HAVE_PTHREADS
 272     pthread_t thread;           /* thread reading from this file */
 273     int finished;               /* the thread has exited */
 274     int joined;                 /* the thread has been joined */
 275     pthread_mutex_t fifo_lock;  /* lock for access to fifo */
 276     pthread_cond_t  fifo_cond;  /* the main thread will signal on this cond after reading from fifo */
 277     AVFifoBuffer *fifo;         /* demuxed packets are stored here; freed by the main thread */
 278 #endif
 279 } InputFile;
 280
 281 typedef struct OutputStream {
 282     int file_index;          /* file index */
 283     int index;               /* stream index in the output file */
 284     int source_index;        /* InputStream index */
 285     AVStream *st;            /* stream in the output file */
 286     int encoding_needed;     /* true if encoding needed for this stream */
 287     int frame_number;
 288     /* input pts and corresponding output pts
 289        for A/V sync */
 290     struct InputStream *sync_ist; /* input stream to sync against */
 291     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
 292     /* pts of the first frame encoded for this stream, used for limiting
 293      * recording time */
 294     int64_t first_pts;
 295     AVBitStreamFilterContext *bitstream_filters;
 296     AVCodec *enc;
 297     int64_t max_frames;
 298     AVFrame *filtered_frame;
 299
 300     /* video only */
 301     AVRational frame_rate;
 302     int force_fps;
 303     int top_field_first;
 304
 305     float frame_aspect_ratio;
 306     float last_quality;
 307
 308     /* forced key frames */
 309     int64_t *forced_kf_pts;
 310     int forced_kf_count;
 311     int forced_kf_index;
 312     char *forced_keyframes;
 313
 314     /* audio only */
 315     int audio_channels_map[SWR_CH_MAX];  /* list of the channels id to pick from the source stream */
 316     int audio_channels_mapped;           /* number of channels in audio_channels_map */
 317
 318     FILE *logfile;
 319
 320     OutputFilter *filter;
 321     char *avfilter;
 322
 323     int64_t sws_flags;
 324     int64_t swr_dither_method;
 325     double swr_dither_scale;
 326     AVDictionary *opts;
 327     int is_past_recording_time;
 328     int stream_copy;
 329     const char *attachment_filename;
 330     int copy_initial_nonkeyframes;
 331
 332     int keep_pix_fmt;
 333 } OutputStream;
 334
 335
 336 #if HAVE_TERMIOS_H
 337
 338 /* init terminal so that we can grab keys */
 339 static struct termios oldtty;
 340 static int restore_tty;
 341 #endif
 342
 343 typedef struct OutputFile {
 344     AVFormatContext *ctx;
 345     AVDictionary *opts;
 346     int ost_index;       /* index of the first stream in output_streams */
 347     int64_t recording_time; /* desired length of the resulting file in microseconds */
 348     int64_t start_time;     /* start time in microseconds */
 349     uint64_t limit_filesize; /* filesize limit expressed in bytes */
 350 } OutputFile;
 351
 352 static InputStream **input_streams = NULL;
 353 static int        nb_input_streams = 0;
 354 static InputFile   **input_files   = NULL;
 355 static int        nb_input_files   = 0;
 356
 357 static OutputStream **output_streams = NULL;
 358 static int         nb_output_streams = 0;
 359 static OutputFile   **output_files   = NULL;
 360 static int         nb_output_files   = 0;
 361
 362 static FilterGraph **filtergraphs;
 363 int               nb_filtergraphs;
 364
 365 typedef struct OptionsContext {
 366     /* input/output options */
 367     int64_t start_time;
 368     const char *format;
 369
 370     SpecifierOpt *codec_names;
 371     int        nb_codec_names;
 372     SpecifierOpt *audio_channels;
 373     int        nb_audio_channels;
 374     SpecifierOpt *audio_sample_rate;
 375     int        nb_audio_sample_rate;
 376     SpecifierOpt *frame_rates;
 377     int        nb_frame_rates;
 378     SpecifierOpt *frame_sizes;
 379     int        nb_frame_sizes;
 380     SpecifierOpt *frame_pix_fmts;
 381     int        nb_frame_pix_fmts;
 382
 383     /* input options */
 384     int64_t input_ts_offset;
 385     int rate_emu;
 386
 387     SpecifierOpt *ts_scale;
 388     int        nb_ts_scale;
 389     SpecifierOpt *dump_attachment;
 390     int        nb_dump_attachment;
 391
 392     /* output options */
 393     StreamMap *stream_maps;
 394     int     nb_stream_maps;
 395     AudioChannelMap *audio_channel_maps; /* one info entry per -map_channel */
 396     int           nb_audio_channel_maps; /* number of (valid) -map_channel settings */
 397     int metadata_global_manual;
 398     int metadata_streams_manual;
 399     int metadata_chapters_manual;
 400     const char **attachments;
 401     int       nb_attachments;
 402
 403     int chapters_input_file;
 404
 405     int64_t recording_time;
 406     uint64_t limit_filesize;
 407     float mux_preload;
 408     float mux_max_delay;
 409
 410     int video_disable;
 411     int audio_disable;
 412     int subtitle_disable;
 413     int data_disable;
 414
 415     /* indexed by output file stream index */
 416     int   *streamid_map;
 417     int nb_streamid_map;
 418
 419     SpecifierOpt *metadata;
 420     int        nb_metadata;
 421     SpecifierOpt *max_frames;
 422     int        nb_max_frames;
 423     SpecifierOpt *bitstream_filters;
 424     int        nb_bitstream_filters;
 425     SpecifierOpt *codec_tags;
 426     int        nb_codec_tags;
 427     SpecifierOpt *sample_fmts;
 428     int        nb_sample_fmts;
 429     SpecifierOpt *qscale;
 430     int        nb_qscale;
 431     SpecifierOpt *forced_key_frames;
 432     int        nb_forced_key_frames;
 433     SpecifierOpt *force_fps;
 434     int        nb_force_fps;
 435     SpecifierOpt *frame_aspect_ratios;
 436     int        nb_frame_aspect_ratios;
 437     SpecifierOpt *rc_overrides;
 438     int        nb_rc_overrides;
 439     SpecifierOpt *intra_matrices;
 440     int        nb_intra_matrices;
 441     SpecifierOpt *inter_matrices;
 442     int        nb_inter_matrices;
 443     SpecifierOpt *top_field_first;
 444     int        nb_top_field_first;
 445     SpecifierOpt *metadata_map;
 446     int        nb_metadata_map;
 447     SpecifierOpt *presets;
 448     int        nb_presets;
 449     SpecifierOpt *copy_initial_nonkeyframes;
 450     int        nb_copy_initial_nonkeyframes;
 451     SpecifierOpt *filters;
 452     int        nb_filters;
 453 } OptionsContext;
 454
 455 static void do_video_stats(AVFormatContext *os, OutputStream *ost, int frame_size);
 456
 457 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
 458 {\
 459     int i, ret;\
 460     for (i = 0; i < o->nb_ ## name; i++) {\
 461         char *spec = o->name[i].specifier;\
 462         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
 463             outvar = o->name[i].u.type;\
 464         else if (ret < 0)\
 465             exit_program(1);\
 466     }\
 467 }
 468
 469 static int64_t getutime(void)
 470 {
 471 #if HAVE_GETRUSAGE
 472     struct rusage rusage;
 473
 474     getrusage(RUSAGE_SELF, &rusage);
 475     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
 476 #elif HAVE_GETPROCESSTIMES
 477     HANDLE proc;
 478     FILETIME c, e, k, u;
 479     proc = GetCurrentProcess();
 480     GetProcessTimes(proc, &c, &e, &k, &u);
 481     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
 482 #else
 483     return av_gettime();
 484 #endif
 485 }
 486
 487 static void update_benchmark(const char *fmt, ...)
 488 {
 489     if (do_benchmark_all) {
 490         int64_t t = getutime();
 491         va_list va;
 492         char buf[1024];
 493
 494         if (fmt) {
 495             va_start(va, fmt);
 496             vsnprintf(buf, sizeof(buf), fmt, va);
 497             va_end(va);
 498             printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
 499         }
 500         current_time = t;
 501     }
 502 }
 503
 504 static void reset_options(OptionsContext *o, int is_input)
 505 {
 506     const OptionDef *po = options;
 507     OptionsContext bak= *o;
 508     int i;
 509
 510     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
 511     while (po->name) {
 512         void *dst = (uint8_t*)o + po->u.off;
 513
 514         if (po->flags & OPT_SPEC) {
 515             SpecifierOpt **so = dst;
 516             int i, *count = (int*)(so + 1);
 517             for (i = 0; i < *count; i++) {
 518                 av_freep(&(*so)[i].specifier);
 519                 if (po->flags & OPT_STRING)
 520                     av_freep(&(*so)[i].u.str);
 521             }
 522             av_freep(so);
 523             *count = 0;
 524         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
 525             av_freep(dst);
 526         po++;
 527     }
 528
 529     for (i = 0; i < o->nb_stream_maps; i++)
 530         av_freep(&o->stream_maps[i].linklabel);
 531     av_freep(&o->stream_maps);
 532     av_freep(&o->audio_channel_maps);
 533     av_freep(&o->streamid_map);
 534
 535     memset(o, 0, sizeof(*o));
 536
 537     if (is_input) {
 538         o->recording_time = bak.recording_time;
 539         if (o->recording_time != INT64_MAX)
 540             av_log(NULL, AV_LOG_WARNING,
 541                    "-t is not an input option, keeping it for the next output;"
 542                    " consider fixing your command line.\n");
 543     } else
 544         o->recording_time = INT64_MAX;
 545     o->mux_max_delay  = 0.7;
 546     o->limit_filesize = UINT64_MAX;
 547     o->chapters_input_file = INT_MAX;
 548
 549     uninit_opts();
 550     init_opts();
 551 }
 552
 553 static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
 554 {
 555     if (codec && codec->pix_fmts) {
 556         const enum PixelFormat *p = codec->pix_fmts;
 557         int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
 558         enum PixelFormat best= PIX_FMT_NONE;
 559         if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
 560             if (st->codec->codec_id == CODEC_ID_MJPEG) {
 561                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
 562             } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
 563                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
 564                                                  PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
 565             }
 566         }
 567         for (; *p != PIX_FMT_NONE; p++) {
 568             best= avcodec_find_best_pix_fmt2(best, *p, target, has_alpha, NULL);
 569             if (*p == target)
 570                 break;
 571         }
 572         if (*p == PIX_FMT_NONE) {
 573             if (target != PIX_FMT_NONE)
 574                 av_log(NULL, AV_LOG_WARNING,
 575                        "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 576                        av_pix_fmt_descriptors[target].name,
 577                        codec->name,
 578                        av_pix_fmt_descriptors[best].name);
 579             return best;
 580         }
 581     }
 582     return target;
 583 }
 584
 585 static char *choose_pix_fmts(OutputStream *ost)
 586 {
 587      if (ost->keep_pix_fmt) {
 588         if (ost->filter)
 589             avfilter_graph_set_auto_convert(ost->filter->graph->graph,
 590                                             AVFILTER_AUTO_CONVERT_NONE);
 591         if (ost->st->codec->pix_fmt == PIX_FMT_NONE)
 592             return NULL;
 593         return av_strdup(av_get_pix_fmt_name(ost->st->codec->pix_fmt));
 594     }
 595     if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
 596         return av_strdup(av_get_pix_fmt_name(choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt)));
 597     } else if (ost->enc && ost->enc->pix_fmts) {
 598         const enum PixelFormat *p;
 599         AVIOContext *s = NULL;
 600         uint8_t *ret;
 601         int len;
 602
 603         if (avio_open_dyn_buf(&s) < 0)
 604             exit_program(1);
 605
 606         p = ost->enc->pix_fmts;
 607         if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
 608             if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
 609                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
 610             } else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
 611                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
 612                                                     PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
 613             }
 614         }
 615
 616         for (; *p != PIX_FMT_NONE; p++) {
 617             const char *name = av_get_pix_fmt_name(*p);
 618             avio_printf(s, "%s:", name);
 619         }
 620         len = avio_close_dyn_buf(s, &ret);
 621         ret[len - 1] = 0;
 622         return ret;
 623     } else
 624         return NULL;
 625 }
 626
 627 /**
 628  * Define a function for building a string containing a list of
 629  * allowed formats,
 630  */
 631 #define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \
 632 static char *choose_ ## var ## s(OutputStream *ost)                             \
 633 {                                                                               \
 634     if (ost->st->codec->var != none) {                                          \
 635         get_name(ost->st->codec->var);                                          \
 636         return av_strdup(name);                                                 \
 637     } else if (ost->enc->supported_list) {                                      \
 638         const type *p;                                                          \
 639         AVIOContext *s = NULL;                                                  \
 640         uint8_t *ret;                                                           \
 641         int len;                                                                \
 642                                                                                 \
 643         if (avio_open_dyn_buf(&s) < 0)                                          \
 644             exit_program(1);                                                    \
 645                                                                                 \
 646         for (p = ost->enc->supported_list; *p != none; p++) {                   \
 647             get_name(*p);                                                       \
 648             avio_printf(s, "%s" separator, name);                               \
 649         }                                                                       \
 650         len = avio_close_dyn_buf(s, &ret);                                      \
 651         ret[len - 1] = 0;                                                       \
 652         return ret;                                                             \
 653     } else                                                                      \
 654         return NULL;                                                            \
 655 }
 656
 657 #define GET_PIX_FMT_NAME(pix_fmt)\
 658     const char *name = av_get_pix_fmt_name(pix_fmt);
 659
 660 // DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
 661 //                   GET_PIX_FMT_NAME, ":")
 662
 663 #define GET_SAMPLE_FMT_NAME(sample_fmt)\
 664     const char *name = av_get_sample_fmt_name(sample_fmt)
 665
 666 DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
 667                   AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",")
 668
 669 #define GET_SAMPLE_RATE_NAME(rate)\
 670     char name[16];\
 671     snprintf(name, sizeof(name), "%d", rate);
 672
 673 DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0,
 674                   GET_SAMPLE_RATE_NAME, ",")
 675
 676 #define GET_CH_LAYOUT_NAME(ch_layout)\
 677     char name[16];\
 678     snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout);
 679
 680 DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0,
 681                   GET_CH_LAYOUT_NAME, ",")
 682
 683 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
 684 {
 685     FilterGraph *fg = av_mallocz(sizeof(*fg));
 686
 687     if (!fg)
 688         exit_program(1);
 689     fg->index = nb_filtergraphs;
 690
 691     fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
 692                              fg->nb_outputs + 1);
 693     if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
 694         exit_program(1);
 695     fg->outputs[0]->ost   = ost;
 696     fg->outputs[0]->graph = fg;
 697
 698     ost->filter = fg->outputs[0];
 699
 700     fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
 701                             fg->nb_inputs + 1);
 702     if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
 703         exit_program(1);
 704     fg->inputs[0]->ist   = ist;
 705     fg->inputs[0]->graph = fg;
 706
 707     ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
 708                               &ist->nb_filters, ist->nb_filters + 1);
 709     ist->filters[ist->nb_filters - 1] = fg->inputs[0];
 710
 711     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
 712                               &nb_filtergraphs, nb_filtergraphs + 1);
 713     filtergraphs[nb_filtergraphs - 1] = fg;
 714
 715     return fg;
 716 }
 717
 718 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
 719 {
 720     InputStream *ist = NULL;
 721     enum AVMediaType type = avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx);
 722     int i;
 723
 724     // TODO: support other filter types
 725     if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO) {
 726         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters supported "
 727                "currently.\n");
 728         exit_program(1);
 729     }
 730
 731     if (in->name) {
 732         AVFormatContext *s;
 733         AVStream       *st = NULL;
 734         char *p;
 735         int file_idx = strtol(in->name, &p, 0);
 736
 737         if (file_idx < 0 || file_idx >= nb_input_files) {
 738             av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
 739                    file_idx, fg->graph_desc);
 740             exit_program(1);
 741         }
 742         s = input_files[file_idx]->ctx;
 743
 744         for (i = 0; i < s->nb_streams; i++) {
 745             if (s->streams[i]->codec->codec_type != type)
 746                 continue;
 747             if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
 748                 st = s->streams[i];
 749                 break;
 750             }
 751         }
 752         if (!st) {
 753             av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
 754                    "matches no streams.\n", p, fg->graph_desc);
 755             exit_program(1);
 756         }
 757         ist = input_streams[input_files[file_idx]->ist_index + st->index];
 758     } else {
 759         /* find the first unused stream of corresponding type */
 760         for (i = 0; i < nb_input_streams; i++) {
 761             ist = input_streams[i];
 762             if (ist->st->codec->codec_type == type && ist->discard)
 763                 break;
 764         }
 765         if (i == nb_input_streams) {
 766             av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
 767                    "unlabeled input pad %d on filter %s\n", in->pad_idx,
 768                    in->filter_ctx->name);
 769             exit_program(1);
 770         }
 771     }
 772     av_assert0(ist);
 773
 774     ist->discard         = 0;
 775     ist->decoding_needed = 1;
 776     ist->st->discard = AVDISCARD_NONE;
 777
 778     fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
 779                             &fg->nb_inputs, fg->nb_inputs + 1);
 780     if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
 781         exit_program(1);
 782     fg->inputs[fg->nb_inputs - 1]->ist   = ist;
 783     fg->inputs[fg->nb_inputs - 1]->graph = fg;
 784
 785     ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
 786                               &ist->nb_filters, ist->nb_filters + 1);
 787     ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
 788 }
 789
 790 static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
 791 {
 792     char *pix_fmts;
 793     OutputStream *ost = ofilter->ost;
 794     AVCodecContext *codec = ost->st->codec;
 795     AVFilterContext *last_filter = out->filter_ctx;
 796     int pad_idx = out->pad_idx;
 797     int ret;
 798     char name[255];
 799     AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
 800
 801     snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
 802     ret = avfilter_graph_create_filter(&ofilter->filter,
 803                                        avfilter_get_by_name("buffersink"),
 804                                        name, NULL, NULL/*buffersink_params*/, fg->graph);
 805     av_freep(&buffersink_params);
 806
 807     if (ret < 0)
 808         return ret;
 809
 810     if (codec->width || codec->height) {
 811         char args[255];
 812         AVFilterContext *filter;
 813
 814         snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
 815                  codec->width,
 816                  codec->height,
 817                  (unsigned)ost->sws_flags);
 818         snprintf(name, sizeof(name), "scaler for output stream %d:%d",
 819                  ost->file_index, ost->index);
 820         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 821                                                 name, args, NULL, fg->graph)) < 0)
 822             return ret;
 823         if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
 824             return ret;
 825
 826         last_filter = filter;
 827         pad_idx = 0;
 828     }
 829
 830     if ((pix_fmts = choose_pix_fmts(ost))) {
 831         AVFilterContext *filter;
 832         snprintf(name, sizeof(name), "pixel format for output stream %d:%d",
 833                  ost->file_index, ost->index);
 834         if ((ret = avfilter_graph_create_filter(&filter,
 835                                                 avfilter_get_by_name("format"),
 836                                                 "format", pix_fmts, NULL,
 837                                                 fg->graph)) < 0)
 838             return ret;
 839         if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
 840             return ret;
 841
 842         last_filter = filter;
 843         pad_idx     = 0;
 844         av_freep(&pix_fmts);
 845     }
 846
 847     if (ost->frame_rate.num && 0) {
 848         AVFilterContext *fps;
 849         char args[255];
 850
 851         snprintf(args, sizeof(args), "fps=%d/%d", ost->frame_rate.num,
 852                  ost->frame_rate.den);
 853         snprintf(name, sizeof(name), "fps for output stream %d:%d",
 854                  ost->file_index, ost->index);
 855         ret = avfilter_graph_create_filter(&fps, avfilter_get_by_name("fps"),
 856                                            name, args, NULL, fg->graph);
 857         if (ret < 0)
 858             return ret;
 859
 860         ret = avfilter_link(last_filter, pad_idx, fps, 0);
 861         if (ret < 0)
 862             return ret;
 863         last_filter = fps;
 864         pad_idx = 0;
 865     }
 866
 867     if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
 868         return ret;
 869
 870     return 0;
 871 }
 872
 873 static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
 874 {
 875     OutputStream *ost = ofilter->ost;
 876     AVCodecContext *codec  = ost->st->codec;
 877     AVFilterContext *last_filter = out->filter_ctx;
 878     int pad_idx = out->pad_idx;
 879     char *sample_fmts, *sample_rates, *channel_layouts;
 880     char name[255];
 881     int ret;
 882
 883
 884     snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
 885     ret = avfilter_graph_create_filter(&ofilter->filter,
 886                                        avfilter_get_by_name("abuffersink"),
 887                                        name, NULL, NULL, fg->graph);
 888     if (ret < 0)
 889         return ret;
 890
 891 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do {                 \
 892     AVFilterContext *filt_ctx;                                              \
 893                                                                             \
 894     av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi "            \
 895            "similarly to -af " filter_name "=%s.\n", arg);                  \
 896                                                                             \
 897     ret = avfilter_graph_create_filter(&filt_ctx,                           \
 898                                        avfilter_get_by_name(filter_name),   \
 899                                        filter_name, arg, NULL, fg->graph);  \
 900     if (ret < 0)                                                            \
 901         return ret;                                                         \
 902                                                                             \
 903     ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0);                 \
 904     if (ret < 0)                                                            \
 905         return ret;                                                         \
 906                                                                             \
 907     last_filter = filt_ctx;                                                 \
 908     pad_idx = 0;                                                            \
 909 } while (0)
 910     if (ost->audio_channels_mapped) {
 911         int i;
 912         AVBPrint pan_buf;
 913         av_bprint_init(&pan_buf, 256, 8192);
 914         av_bprintf(&pan_buf, "0x%"PRIx64,
 915                    av_get_default_channel_layout(ost->audio_channels_mapped));
 916         for (i = 0; i < ost->audio_channels_mapped; i++)
 917             if (ost->audio_channels_map[i] != -1)
 918                 av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
 919
 920         AUTO_INSERT_FILTER("-map_channel", "pan", pan_buf.str);
 921         av_bprint_finalize(&pan_buf, NULL);
 922     }
 923
 924     if (codec->channels && !codec->channel_layout)
 925         codec->channel_layout = av_get_default_channel_layout(codec->channels);
 926
 927     sample_fmts     = choose_sample_fmts(ost);
 928     sample_rates    = choose_sample_rates(ost);
 929     channel_layouts = choose_channel_layouts(ost);
 930     if (sample_fmts || sample_rates || channel_layouts) {
 931         AVFilterContext *format;
 932         char args[256];
 933         int len = 0;
 934
 935         if (sample_fmts)
 936             len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
 937                             sample_fmts);
 938         if (sample_rates)
 939             len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
 940                             sample_rates);
 941         if (channel_layouts)
 942             len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
 943                             channel_layouts);
 944         args[len - 1] = 0;
 945
 946         av_freep(&sample_fmts);
 947         av_freep(&sample_rates);
 948         av_freep(&channel_layouts);
 949
 950         snprintf(name, sizeof(name), "audio format for output stream %d:%d",
 951                  ost->file_index, ost->index);
 952         ret = avfilter_graph_create_filter(&format,
 953                                            avfilter_get_by_name("aformat"),
 954                                            name, args, NULL, fg->graph);
 955         if (ret < 0)
 956             return ret;
 957
 958         ret = avfilter_link(last_filter, pad_idx, format, 0);
 959         if (ret < 0)
 960             return ret;
 961
 962         last_filter = format;
 963         pad_idx = 0;
 964     }
 965
 966     if (audio_volume != 256 && 0) {
 967         char args[256];
 968
 969         snprintf(args, sizeof(args), "%f", audio_volume / 256.);
 970         AUTO_INSERT_FILTER("-vol", "volume", args);
 971     }
 972
 973     if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
 974         return ret;
 975
 976     return 0;
 977 }
 978
 979 #define DESCRIBE_FILTER_LINK(f, inout, in)                         \
 980 {                                                                  \
 981     AVFilterContext *ctx = inout->filter_ctx;                      \
 982     AVFilterPad *pads = in ? ctx->input_pads  : ctx->output_pads;  \
 983     int       nb_pads = in ? ctx->input_count : ctx->output_count; \
 984     AVIOContext *pb;                                               \
 985                                                                    \
 986     if (avio_open_dyn_buf(&pb) < 0)                                \
 987         exit_program(1);                                           \
 988                                                                    \
 989     avio_printf(pb, "%s", ctx->filter->name);                      \
 990     if (nb_pads > 1)                                               \
 991         avio_printf(pb, ":%s", avfilter_pad_get_name(pads, inout->pad_idx));\
 992     avio_w8(pb, 0);                                                \
 993     avio_close_dyn_buf(pb, &f->name);                              \
 994 }
 995
 996 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
 997 {
 998     av_freep(&ofilter->name);
 999     DESCRIBE_FILTER_LINK(ofilter, out, 0);
1000
1001     switch (avfilter_pad_get_type(out->filter_ctx->output_pads, out->pad_idx)) {
1002     case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
1003     case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
1004     default: av_assert0(0);
1005     }
1006 }
1007
1008 static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
1009                                         AVFilterInOut *in)
1010 {
1011     AVFilterContext *first_filter = in->filter_ctx;
1012     AVFilter *filter = avfilter_get_by_name("buffer");
1013     InputStream *ist = ifilter->ist;
1014     AVRational tb = ist->framerate.num ? (AVRational){ist->framerate.den,
1015                                                       ist->framerate.num} :
1016                                          ist->st->time_base;
1017     AVRational fr = ist->framerate.num ? ist->framerate :
1018                                          ist->st->r_frame_rate;
1019     AVRational sar;
1020     AVBPrint args;
1021     char name[255];
1022     int pad_idx = in->pad_idx;
1023     int ret;
1024
1025     sar = ist->st->sample_aspect_ratio.num ?
1026           ist->st->sample_aspect_ratio :
1027           ist->st->codec->sample_aspect_ratio;
1028     if(!sar.den)
1029         sar = (AVRational){0,1};
1030     av_bprint_init(&args, 0, 1);
1031     av_bprintf(&args,
1032              "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:"
1033              "pixel_aspect=%d/%d:sws_param=flags=%d", ist->st->codec->width,
1034              ist->st->codec->height, ist->st->codec->pix_fmt,
1035              tb.num, tb.den, sar.num, sar.den,
1036              SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
1037     if (fr.num && fr.den)
1038         av_bprintf(&args, ":frame_rate=%d/%d", fr.num, fr.den);
1039     snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
1040              ist->file_index, ist->st->index);
1041
1042     if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter, name,
1043                                             args.str, NULL, fg->graph)) < 0)
1044         return ret;
1045
1046     if (ist->framerate.num) {
1047         AVFilterContext *setpts;
1048
1049         snprintf(name, sizeof(name), "force CFR for input from stream %d:%d",
1050                  ist->file_index, ist->st->index);
1051         if ((ret = avfilter_graph_create_filter(&setpts,
1052                                                 avfilter_get_by_name("setpts"),
1053                                                 name, "N", NULL,
1054                                                 fg->graph)) < 0)
1055             return ret;
1056
1057         if ((ret = avfilter_link(setpts, 0, first_filter, pad_idx)) < 0)
1058             return ret;
1059
1060         first_filter = setpts;
1061         pad_idx = 0;
1062     }
1063
1064     if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
1065         return ret;
1066     return 0;
1067 }
1068
1069 static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
1070                                         AVFilterInOut *in)
1071 {
1072     AVFilterContext *first_filter = in->filter_ctx;
1073     AVFilter *filter = avfilter_get_by_name("abuffer");
1074     InputStream *ist = ifilter->ist;
1075     int pad_idx = in->pad_idx;
1076     char args[255], name[255];
1077     int ret;
1078
1079     snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s"
1080              ":channel_layout=0x%"PRIx64,
1081              1, ist->st->codec->sample_rate,
1082              ist->st->codec->sample_rate,
1083              av_get_sample_fmt_name(ist->st->codec->sample_fmt),
1084              ist->st->codec->channel_layout);
1085     snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
1086              ist->file_index, ist->st->index);
1087
1088     if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter,
1089                                             name, args, NULL,
1090                                             fg->graph)) < 0)
1091         return ret;
1092
1093 #define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do {                 \
1094     AVFilterContext *filt_ctx;                                              \
1095                                                                             \
1096     av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi "            \
1097            "similarly to -af " filter_name "=%s.\n", arg);                  \
1098                                                                             \
1099     snprintf(name, sizeof(name), "graph %d %s for input stream %d:%d",      \
1100                 fg->index, filter_name, ist->file_index, ist->st->index);   \
1101     ret = avfilter_graph_create_filter(&filt_ctx,                           \
1102                                        avfilter_get_by_name(filter_name),   \
1103                                        name, arg, NULL, fg->graph);         \
1104     if (ret < 0)                                                            \
1105         return ret;                                                         \
1106                                                                             \
1107     ret = avfilter_link(filt_ctx, 0, first_filter, pad_idx);                \
1108     if (ret < 0)                                                            \
1109         return ret;                                                         \
1110                                                                             \
1111     first_filter = filt_ctx;                                                  \
1112 } while (0)
1113
1114     if (audio_sync_method > 0) {
1115         char args[256] = {0};
1116
1117         av_strlcatf(args, sizeof(args), "min_comp=0.001:min_hard_comp=%f", audio_drift_threshold);
1118         if (audio_sync_method > 1)
1119             av_strlcatf(args, sizeof(args), ":max_soft_comp=%f", audio_sync_method/(double)ist->st->codec->sample_rate);
1120         AUTO_INSERT_FILTER_INPUT("-async", "aresample", args);
1121     }
1122
1123 //     if (ost->audio_channels_mapped) {
1124 //         int i;
1125 //         AVBPrint pan_buf;
1126 //         av_bprint_init(&pan_buf, 256, 8192);
1127 //         av_bprintf(&pan_buf, "0x%"PRIx64,
1128 //                    av_get_default_channel_layout(ost->audio_channels_mapped));
1129 //         for (i = 0; i < ost->audio_channels_mapped; i++)
1130 //             if (ost->audio_channels_map[i] != -1)
1131 //                 av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
1132 //         AUTO_INSERT_FILTER_INPUT("-map_channel", "pan", pan_buf.str);
1133 //         av_bprint_finalize(&pan_buf, NULL);
1134 //     }
1135
1136     if (audio_volume != 256) {
1137         char args[256];
1138
1139         snprintf(args, sizeof(args), "%f", audio_volume / 256.);
1140         AUTO_INSERT_FILTER_INPUT("-vol", "volume", args);
1141     }
1142     if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
1143         return ret;
1144
1145     return 0;
1146 }
1147
1148 static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter,
1149                                   AVFilterInOut *in)
1150 {
1151     av_freep(&ifilter->name);
1152     DESCRIBE_FILTER_LINK(ifilter, in, 1);
1153
1154     switch (avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx)) {
1155     case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, ifilter, in);
1156     case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, ifilter, in);
1157     default: av_assert0(0);
1158     }
1159 }
1160
1161 static int configure_filtergraph(FilterGraph *fg)
1162 {
1163     AVFilterInOut *inputs, *outputs, *cur;
1164     int ret, i, init = !fg->graph, simple = !fg->graph_desc;
1165     const char *graph_desc = simple ? fg->outputs[0]->ost->avfilter :
1166                                       fg->graph_desc;
1167
1168     avfilter_graph_free(&fg->graph);
1169     if (!(fg->graph = avfilter_graph_alloc()))
1170         return AVERROR(ENOMEM);
1171
1172     if (simple) {
1173         OutputStream *ost = fg->outputs[0]->ost;
1174         char args[255];
1175         snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
1176         fg->graph->scale_sws_opts = av_strdup(args);
1177     }
1178
1179     if ((ret = avfilter_graph_parse2(fg->graph, graph_desc, &inputs, &outputs)) < 0)
1180         return ret;
1181
1182     if (simple && (!inputs || inputs->next || !outputs || outputs->next)) {
1183         av_log(NULL, AV_LOG_ERROR, "Simple filtergraph '%s' does not have "
1184                "exactly one input and output.\n", graph_desc);
1185         return AVERROR(EINVAL);
1186     }
1187
1188     for (cur = inputs; !simple && init && cur; cur = cur->next)
1189         init_input_filter(fg, cur);
1190
1191     for (cur = inputs, i = 0; cur; cur = cur->next, i++)
1192         if ((ret = configure_input_filter(fg, fg->inputs[i], cur)) < 0)
1193             return ret;
1194     avfilter_inout_free(&inputs);
1195
1196     if (!init || simple) {
1197         /* we already know the mappings between lavfi outputs and output streams,
1198          * so we can finish the setup */
1199         for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1200             configure_output_filter(fg, fg->outputs[i], cur);
1201         avfilter_inout_free(&outputs);
1202
1203         if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1204             return ret;
1205     } else {
1206         /* wait until output mappings are processed */
1207         for (cur = outputs; cur;) {
1208             fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1209                                      &fg->nb_outputs, fg->nb_outputs + 1);
1210             if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1211                 exit_program(1);
1212             fg->outputs[fg->nb_outputs - 1]->graph   = fg;
1213             fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1214             cur = cur->next;
1215             fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1216         }
1217     }
1218
1219     return 0;
1220 }
1221
1222 static int configure_complex_filters(void)
1223 {
1224     int i, ret = 0;
1225
1226     for (i = 0; i < nb_filtergraphs; i++)
1227         if (!filtergraphs[i]->graph &&
1228             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1229             return ret;
1230     return 0;
1231 }
1232
1233 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1234 {
1235     int i;
1236     for (i = 0; i < fg->nb_inputs; i++)
1237         if (fg->inputs[i]->ist == ist)
1238             return 1;
1239     return 0;
1240 }
1241
1242 static void term_exit(void)
1243 {
1244     av_log(NULL, AV_LOG_QUIET, "%s", "");
1245 #if HAVE_TERMIOS_H
1246     if(restore_tty)
1247         tcsetattr (0, TCSANOW, &oldtty);
1248 #endif
1249 }
1250
1251 static volatile int received_sigterm = 0;
1252
1253 static void sigterm_handler(int sig)
1254 {
1255     received_sigterm = sig;
1256     received_nb_signals++;
1257     term_exit();
1258     if(received_nb_signals > 3)
1259         exit(123);
1260 }
1261
1262 static void term_init(void)
1263 {
1264 #if HAVE_TERMIOS_H
1265     if(!run_as_daemon){
1266         struct termios tty;
1267         int istty = 1;
1268 #if HAVE_ISATTY
1269         istty = isatty(0) && isatty(2);
1270 #endif
1271         if (istty && tcgetattr (0, &tty) == 0) {
1272             oldtty = tty;
1273             restore_tty = 1;
1274             atexit(term_exit);
1275
1276             tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1277                              |INLCR|IGNCR|ICRNL|IXON);
1278             tty.c_oflag |= OPOST;
1279             tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1280             tty.c_cflag &= ~(CSIZE|PARENB);
1281             tty.c_cflag |= CS8;
1282             tty.c_cc[VMIN] = 1;
1283             tty.c_cc[VTIME] = 0;
1284
1285             tcsetattr (0, TCSANOW, &tty);
1286         }
1287         signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
1288     }
1289 #endif
1290     avformat_network_deinit();
1291
1292     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
1293     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
1294 #ifdef SIGXCPU
1295     signal(SIGXCPU, sigterm_handler);
1296 #endif
1297 }
1298
1299 /* read a key without blocking */
1300 static int read_key(void)
1301 {
1302     unsigned char ch;
1303 #if HAVE_TERMIOS_H
1304     int n = 1;
1305     struct timeval tv;
1306     fd_set rfds;
1307
1308     FD_ZERO(&rfds);
1309     FD_SET(0, &rfds);
1310     tv.tv_sec = 0;
1311     tv.tv_usec = 0;
1312     n = select(1, &rfds, NULL, NULL, &tv);
1313     if (n > 0) {
1314         n = read(0, &ch, 1);
1315         if (n == 1)
1316             return ch;
1317
1318         return n;
1319     }
1320 #elif HAVE_KBHIT
1321 #    if HAVE_PEEKNAMEDPIPE
1322     static int is_pipe;
1323     static HANDLE input_handle;
1324     DWORD dw, nchars;
1325     if(!input_handle){
1326         input_handle = GetStdHandle(STD_INPUT_HANDLE);
1327         is_pipe = !GetConsoleMode(input_handle, &dw);
1328     }
1329
1330     if (stdin->_cnt > 0) {
1331         read(0, &ch, 1);
1332         return ch;
1333     }
1334     if (is_pipe) {
1335         /* When running under a GUI, you will end here. */
1336         if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1337             return -1;
1338         //Read it
1339         if(nchars != 0) {
1340             read(0, &ch, 1);
1341             return ch;
1342         }else{
1343             return -1;
1344         }
1345     }
1346 #    endif
1347     if(kbhit())
1348         return(getch());
1349 #endif
1350     return -1;
1351 }
1352
1353 static int decode_interrupt_cb(void *ctx)
1354 {
1355     return received_nb_signals > 1;
1356 }
1357
1358 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1359
1360 void av_noreturn exit_program(int ret)
1361 {
1362     int i, j;
1363
1364     for (i = 0; i < nb_filtergraphs; i++) {
1365         avfilter_graph_free(&filtergraphs[i]->graph);
1366         for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
1367             av_freep(&filtergraphs[i]->inputs[j]->name);
1368             av_freep(&filtergraphs[i]->inputs[j]);
1369         }
1370         av_freep(&filtergraphs[i]->inputs);
1371         for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
1372             av_freep(&filtergraphs[i]->outputs[j]->name);
1373             av_freep(&filtergraphs[i]->outputs[j]);
1374         }
1375         av_freep(&filtergraphs[i]->outputs);
1376         av_freep(&filtergraphs[i]);
1377     }
1378     av_freep(&filtergraphs);
1379
1380     av_freep(&subtitle_out);
1381
1382     /* close files */
1383     for (i = 0; i < nb_output_files; i++) {
1384         AVFormatContext *s = output_files[i]->ctx;
1385         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1386             avio_close(s->pb);
1387         avformat_free_context(s);
1388         av_dict_free(&output_files[i]->opts);
1389         av_freep(&output_files[i]);
1390     }
1391     for (i = 0; i < nb_output_streams; i++) {
1392         AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1393         while (bsfc) {
1394             AVBitStreamFilterContext *next = bsfc->next;
1395             av_bitstream_filter_close(bsfc);
1396             bsfc = next;
1397         }
1398         output_streams[i]->bitstream_filters = NULL;
1399
1400         av_freep(&output_streams[i]->forced_keyframes);
1401         av_freep(&output_streams[i]->filtered_frame);
1402         av_freep(&output_streams[i]->avfilter);
1403         av_freep(&output_streams[i]);
1404     }
1405     for (i = 0; i < nb_input_files; i++) {
1406         avformat_close_input(&input_files[i]->ctx);
1407         av_freep(&input_files[i]);
1408     }
1409     for (i = 0; i < nb_input_streams; i++) {
1410         av_freep(&input_streams[i]->decoded_frame);
1411         av_dict_free(&input_streams[i]->opts);
1412         free_buffer_pool(&input_streams[i]->buffer_pool);
1413         av_freep(&input_streams[i]->filters);
1414         av_freep(&input_streams[i]);
1415     }
1416
1417     if (vstats_file)
1418         fclose(vstats_file);
1419     av_free(vstats_filename);
1420
1421     av_freep(&input_streams);
1422     av_freep(&input_files);
1423     av_freep(&output_streams);
1424     av_freep(&output_files);
1425
1426     uninit_opts();
1427
1428     avfilter_uninit();
1429     avformat_network_deinit();
1430
1431     if (received_sigterm) {
1432         av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1433                (int) received_sigterm);
1434         exit (255);
1435     }
1436
1437     exit(ret);
1438 }
1439
1440 static void assert_avoptions(AVDictionary *m)
1441 {
1442     AVDictionaryEntry *t;
1443     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1444         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1445         exit_program(1);
1446     }
1447 }
1448
1449 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1450 {
1451     const char *codec_string = encoder ? "encoder" : "decoder";
1452     AVCodec *codec;
1453     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1454         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1455         av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1456                 "results.\nAdd '-strict experimental' if you want to use it.\n",
1457                 codec_string, c->codec->name);
1458         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1459         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1460             av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1461                    codec_string, codec->name);
1462         exit_program(1);
1463     }
1464 }
1465
1466 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1467 {
1468     if (codec && codec->sample_fmts) {
1469         const enum AVSampleFormat *p = codec->sample_fmts;
1470         for (; *p != -1; p++) {
1471             if (*p == st->codec->sample_fmt)
1472                 break;
1473         }
1474         if (*p == -1) {
1475             if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1476                 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1477             if(av_get_sample_fmt_name(st->codec->sample_fmt))
1478             av_log(NULL, AV_LOG_WARNING,
1479                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1480                    av_get_sample_fmt_name(st->codec->sample_fmt),
1481                    codec->name,
1482                    av_get_sample_fmt_name(codec->sample_fmts[0]));
1483             st->codec->sample_fmt = codec->sample_fmts[0];
1484         }
1485     }
1486 }
1487
1488 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1489 {
1490     AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1491     AVCodecContext          *avctx = ost->st->codec;
1492     int ret;
1493
1494     if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1495         (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1496         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1497
1498     if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1499         int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1500         if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE &&  max > pkt->dts) {
1501             av_log(s, max - pkt->dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt->dts, max);
1502             pkt->pts = pkt->dts = max;
1503         }
1504     }
1505
1506     /*
1507      * Audio encoders may split the packets --  #frames in != #packets out.
1508      * But there is no reordering, so we can limit the number of output packets
1509      * by simply dropping them here.
1510      * Counting encoded video frames needs to be done separately because of
1511      * reordering, see do_video_out()
1512      */
1513     if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1514         if (ost->frame_number >= ost->max_frames) {
1515             av_free_packet(pkt);
1516             return;
1517         }
1518         ost->frame_number++;
1519     }
1520
1521     while (bsfc) {
1522         AVPacket new_pkt = *pkt;
1523         int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1524                                            &new_pkt.data, &new_pkt.size,
1525                                            pkt->data, pkt->size,
1526                                            pkt->flags & AV_PKT_FLAG_KEY);
1527         if (a > 0) {
1528             av_free_packet(pkt);
1529             new_pkt.destruct = av_destruct_packet;
1530         } else if (a < 0) {
1531             av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1532                    bsfc->filter->name, pkt->stream_index,
1533                    avctx->codec ? avctx->codec->name : "copy");
1534             print_error("", a);
1535             if (exit_on_error)
1536                 exit_program(1);
1537         }
1538         *pkt = new_pkt;
1539
1540         bsfc = bsfc->next;
1541     }
1542
1543     pkt->stream_index = ost->index;
1544     ret = av_interleaved_write_frame(s, pkt);
1545     if (ret < 0) {
1546         print_error("av_interleaved_write_frame()", ret);
1547         exit_program(1);
1548     }
1549 }
1550
1551 static int check_recording_time(OutputStream *ost)
1552 {
1553     OutputFile *of = output_files[ost->file_index];
1554
1555     if (of->recording_time != INT64_MAX &&
1556         av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
1557                       AV_TIME_BASE_Q) >= 0) {
1558         ost->is_past_recording_time = 1;
1559         return 0;
1560     }
1561     return 1;
1562 }
1563
1564 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1565                          AVFrame *frame)
1566 {
1567     AVCodecContext *enc = ost->st->codec;
1568     AVPacket pkt;
1569     int got_packet = 0;
1570
1571     av_init_packet(&pkt);
1572     pkt.data = NULL;
1573     pkt.size = 0;
1574
1575     if (!check_recording_time(ost))
1576         return;
1577
1578     if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
1579         frame->pts = ost->sync_opts;
1580     ost->sync_opts = frame->pts + frame->nb_samples;
1581
1582     av_assert0(pkt.size || !pkt.data);
1583     update_benchmark(NULL);
1584     if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1585         av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1586         exit_program(1);
1587     }
1588     update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1589
1590     if (got_packet) {
1591         if (pkt.pts != AV_NOPTS_VALUE)
1592             pkt.pts      = av_rescale_q(pkt.pts,      enc->time_base, ost->st->time_base);
1593         if (pkt.dts != AV_NOPTS_VALUE)
1594             pkt.dts      = av_rescale_q(pkt.dts,      enc->time_base, ost->st->time_base);
1595         if (pkt.duration > 0)
1596             pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1597
1598         if (debug_ts) {
1599             av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1600                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1601                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1602                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1603         }
1604
1605         write_frame(s, &pkt, ost);
1606
1607         audio_size += pkt.size;
1608         av_free_packet(&pkt);
1609     }
1610 }
1611
1612 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1613 {
1614     AVCodecContext *dec;
1615     AVPicture *picture2;
1616     AVPicture picture_tmp;
1617     uint8_t *buf = 0;
1618
1619     dec = ist->st->codec;
1620
1621     /* deinterlace : must be done before any resize */
1622     if (do_deinterlace) {
1623         int size;
1624
1625         /* create temporary picture */
1626         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1627         buf  = av_malloc(size);
1628         if (!buf)
1629             return;
1630
1631         picture2 = &picture_tmp;
1632         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1633
1634         if (avpicture_deinterlace(picture2, picture,
1635                                  dec->pix_fmt, dec->width, dec->height) < 0) {
1636             /* if error, do not deinterlace */
1637             av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1638             av_free(buf);
1639             buf = NULL;
1640             picture2 = picture;
1641         }
1642     } else {
1643         picture2 = picture;
1644     }
1645
1646     if (picture != picture2)
1647         *picture = *picture2;
1648     *bufp = buf;
1649 }
1650
1651 static void do_subtitle_out(AVFormatContext *s,
1652                             OutputStream *ost,
1653                             InputStream *ist,
1654                             AVSubtitle *sub,
1655                             int64_t pts)
1656 {
1657     int subtitle_out_max_size = 1024 * 1024;
1658     int subtitle_out_size, nb, i;
1659     AVCodecContext *enc;
1660     AVPacket pkt;
1661
1662     if (pts == AV_NOPTS_VALUE) {
1663         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1664         if (exit_on_error)
1665             exit_program(1);
1666         return;
1667     }
1668
1669     enc = ost->st->codec;
1670
1671     if (!subtitle_out) {
1672         subtitle_out = av_malloc(subtitle_out_max_size);
1673     }
1674
1675     /* Note: DVB subtitle need one packet to draw them and one other
1676        packet to clear them */
1677     /* XXX: signal it in the codec context ? */
1678     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1679         nb = 2;
1680     else
1681         nb = 1;
1682
1683     for (i = 0; i < nb; i++) {
1684         ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1685         if (!check_recording_time(ost))
1686             return;
1687
1688         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1689         // start_display_time is required to be 0
1690         sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1691         sub->end_display_time  -= sub->start_display_time;
1692         sub->start_display_time = 0;
1693         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1694                                                     subtitle_out_max_size, sub);
1695         if (subtitle_out_size < 0) {
1696             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1697             exit_program(1);
1698         }
1699
1700         av_init_packet(&pkt);
1701         pkt.data = subtitle_out;
1702         pkt.size = subtitle_out_size;
1703         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1704         pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
1705         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1706             /* XXX: the pts correction is handled here. Maybe handling
1707                it in the codec would be better */
1708             if (i == 0)
1709                 pkt.pts += 90 * sub->start_display_time;
1710             else
1711                 pkt.pts += 90 * sub->end_display_time;
1712         }
1713         write_frame(s, &pkt, ost);
1714         subtitle_size += pkt.size;
1715     }
1716 }
1717
1718 static void do_video_out(AVFormatContext *s,
1719                          OutputStream *ost,
1720                          AVFrame *in_picture,
1721                          float quality)
1722 {
1723     int ret, format_video_sync;
1724     AVPacket pkt;
1725     AVCodecContext *enc = ost->st->codec;
1726     int nb_frames, i;
1727     double sync_ipts, delta;
1728     double duration = 0;
1729     int frame_size = 0;
1730     InputStream *ist = NULL;
1731
1732     if (ost->source_index >= 0)
1733         ist = input_streams[ost->source_index];
1734
1735     if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1736         duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
1737
1738     sync_ipts = in_picture->pts;
1739     delta = sync_ipts - ost->sync_opts + duration;
1740
1741     /* by default, we output a single frame */
1742     nb_frames = 1;
1743
1744     format_video_sync = video_sync_method;
1745     if (format_video_sync == VSYNC_AUTO)
1746         format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1747
1748     switch (format_video_sync) {
1749     case VSYNC_CFR:
1750         // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1751         if (delta < -1.1)
1752             nb_frames = 0;
1753         else if (delta > 1.1)
1754             nb_frames = lrintf(delta);
1755         break;
1756     case VSYNC_VFR:
1757         if (delta <= -0.6)
1758             nb_frames = 0;
1759         else if (delta > 0.6)
1760             ost->sync_opts = lrint(sync_ipts);
1761         break;
1762     case VSYNC_DROP:
1763     case VSYNC_PASSTHROUGH:
1764         ost->sync_opts = lrint(sync_ipts);
1765         break;
1766     default:
1767         av_assert0(0);
1768     }
1769
1770     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1771     if (nb_frames == 0) {
1772         nb_frames_drop++;
1773         av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1774         return;
1775     } else if (nb_frames > 1) {
1776         if (nb_frames > dts_error_threshold * 30) {
1777             av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skiping\n", nb_frames - 1);
1778             nb_frames_drop++;
1779             return;
1780         }
1781         nb_frames_dup += nb_frames - 1;
1782         av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1783     }
1784
1785   /* duplicates frame if needed */
1786   for (i = 0; i < nb_frames; i++) {
1787     av_init_packet(&pkt);
1788     pkt.data = NULL;
1789     pkt.size = 0;
1790
1791     in_picture->pts = ost->sync_opts;
1792
1793     if (!check_recording_time(ost))
1794         return;
1795
1796     if (s->oformat->flags & AVFMT_RAWPICTURE &&
1797         enc->codec->id == CODEC_ID_RAWVIDEO) {
1798         /* raw pictures are written as AVPicture structure to
1799            avoid any copies. We support temporarily the older
1800            method. */
1801         enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1802         enc->coded_frame->top_field_first  = in_picture->top_field_first;
1803         pkt.data   = (uint8_t *)in_picture;
1804         pkt.size   =  sizeof(AVPicture);
1805         pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1806         pkt.flags |= AV_PKT_FLAG_KEY;
1807
1808         write_frame(s, &pkt, ost);
1809         video_size += pkt.size;
1810     } else {
1811         int got_packet;
1812         AVFrame big_picture;
1813
1814         big_picture = *in_picture;
1815         /* better than nothing: use input picture interlaced
1816            settings */
1817         big_picture.interlaced_frame = in_picture->interlaced_frame;
1818         if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1819             if (ost->top_field_first == -1)
1820                 big_picture.top_field_first = in_picture->top_field_first;
1821             else
1822                 big_picture.top_field_first = !!ost->top_field_first;
1823         }
1824
1825         /* handles same_quant here. This is not correct because it may
1826            not be a global option */
1827         big_picture.quality = quality;
1828         if (!enc->me_threshold)
1829             big_picture.pict_type = 0;
1830         if (ost->forced_kf_index < ost->forced_kf_count &&
1831             big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1832             big_picture.pict_type = AV_PICTURE_TYPE_I;
1833             ost->forced_kf_index++;
1834         }
1835         update_benchmark(NULL);
1836         ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1837         update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1838         if (ret < 0) {
1839             av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1840             exit_program(1);
1841         }
1842
1843         if (got_packet) {
1844             if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
1845                 pkt.pts = ost->sync_opts;
1846
1847             if (pkt.pts != AV_NOPTS_VALUE)
1848                 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1849             if (pkt.dts != AV_NOPTS_VALUE)
1850                 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1851
1852             if (debug_ts) {
1853                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1854                     "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1855                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1856                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1857             }
1858
1859             write_frame(s, &pkt, ost);
1860             frame_size = pkt.size;
1861             video_size += pkt.size;
1862             av_free_packet(&pkt);
1863
1864             /* if two pass, output log */
1865             if (ost->logfile && enc->stats_out) {
1866                 fprintf(ost->logfile, "%s", enc->stats_out);
1867             }
1868         }
1869     }
1870     ost->sync_opts++;
1871     /*
1872      * For video, number of frames in == number of packets out.
1873      * But there may be reordering, so we can't throw away frames on encoder
1874      * flush, we need to limit them here, before they go into encoder.
1875      */
1876     ost->frame_number++;
1877   }
1878
1879     if (vstats_filename && frame_size)
1880         do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
1881 }
1882
1883 static double psnr(double d)
1884 {
1885     return -10.0 * log(d) / log(10.0);
1886 }
1887
1888 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1889                            int frame_size)
1890 {
1891     AVCodecContext *enc;
1892     int frame_number;
1893     double ti1, bitrate, avg_bitrate;
1894
1895     /* this is executed just the first time do_video_stats is called */
1896     if (!vstats_file) {
1897         vstats_file = fopen(vstats_filename, "w");
1898         if (!vstats_file) {
1899             perror("fopen");
1900             exit_program(1);
1901         }
1902     }
1903
1904     enc = ost->st->codec;
1905     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1906         frame_number = ost->frame_number;
1907         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1908         if (enc->flags&CODEC_FLAG_PSNR)
1909             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1910
1911         fprintf(vstats_file,"f_size= %6d ", frame_size);
1912         /* compute pts value */
1913         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1914         if (ti1 < 0.01)
1915             ti1 = 0.01;
1916
1917         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1918         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1919         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1920                (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1921         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1922     }
1923 }
1924
1925 /* check for new output on any of the filtergraphs */
1926 static int poll_filters(void)
1927 {
1928     AVFilterBufferRef *picref;
1929     AVFrame *filtered_frame = NULL;
1930     int i, ret, ret_all;
1931     unsigned nb_success, nb_eof;
1932     int64_t frame_pts;
1933
1934     while (1) {
1935         /* Reap all buffers present in the buffer sinks */
1936         for (i = 0; i < nb_output_streams; i++) {
1937             OutputStream *ost = output_streams[i];
1938             OutputFile    *of = output_files[ost->file_index];
1939             int ret = 0;
1940
1941             if (!ost->filter)
1942                 continue;
1943
1944             if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
1945                 return AVERROR(ENOMEM);
1946             } else
1947                 avcodec_get_frame_defaults(ost->filtered_frame);
1948             filtered_frame = ost->filtered_frame;
1949
1950             while (1) {
1951                 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
1952                                                    AV_BUFFERSINK_FLAG_NO_REQUEST);
1953                 if (ret < 0) {
1954                     if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1955                         char buf[256];
1956                         av_strerror(ret, buf, sizeof(buf));
1957                         av_log(NULL, AV_LOG_WARNING,
1958                                "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
1959                     }
1960                     break;
1961                 }
1962                 frame_pts = AV_NOPTS_VALUE;
1963                 if (picref->pts != AV_NOPTS_VALUE) {
1964                     filtered_frame->pts = frame_pts = av_rescale_q(picref->pts,
1965                                                     ost->filter->filter->inputs[0]->time_base,
1966                                                     ost->st->codec->time_base) -
1967                                         av_rescale_q(of->start_time,
1968                                                     AV_TIME_BASE_Q,
1969                                                     ost->st->codec->time_base);
1970
1971                     if (of->start_time && filtered_frame->pts < 0) {
1972                         avfilter_unref_buffer(picref);
1973                         continue;
1974                     }
1975                 }
1976                 //if (ost->source_index >= 0)
1977                 //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1978
1979
1980                 switch (ost->filter->filter->inputs[0]->type) {
1981                 case AVMEDIA_TYPE_VIDEO:
1982                     avfilter_copy_buf_props(filtered_frame, picref);
1983                     filtered_frame->pts = frame_pts;
1984                     if (!ost->frame_aspect_ratio)
1985                         ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
1986
1987                     do_video_out(of->ctx, ost, filtered_frame,
1988                                  same_quant ? ost->last_quality :
1989                                               ost->st->codec->global_quality);
1990                     break;
1991                 case AVMEDIA_TYPE_AUDIO:
1992                     avfilter_copy_buf_props(filtered_frame, picref);
1993                     filtered_frame->pts = frame_pts;
1994                     do_audio_out(of->ctx, ost, filtered_frame);
1995                     break;
1996                 default:
1997                     // TODO support subtitle filters
1998                     av_assert0(0);
1999                 }
2000
2001                 avfilter_unref_buffer(picref);
2002             }
2003         }
2004         /* Request frames through all the graphs */
2005         ret_all = nb_success = nb_eof = 0;
2006         for (i = 0; i < nb_filtergraphs; i++) {
2007             ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2008             if (!ret) {
2009                 nb_success++;
2010             } else if (ret == AVERROR_EOF) {
2011                 nb_eof++;
2012             } else if (ret != AVERROR(EAGAIN)) {
2013                 char buf[256];
2014                 av_strerror(ret, buf, sizeof(buf));
2015                 av_log(NULL, AV_LOG_WARNING,
2016                        "Error in request_frame(): %s\n", buf);
2017                 ret_all = ret;
2018             }
2019         }
2020         if (!nb_success)
2021             break;
2022         /* Try again if anything succeeded */
2023     }
2024     return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2025 }
2026
2027 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2028 {
2029     char buf[1024];
2030     AVBPrint buf_script;
2031     OutputStream *ost;
2032     AVFormatContext *oc;
2033     int64_t total_size;
2034     AVCodecContext *enc;
2035     int frame_number, vid, i;
2036     double bitrate;
2037     int64_t pts = INT64_MAX;
2038     static int64_t last_time = -1;
2039     static int qp_histogram[52];
2040     int hours, mins, secs, us;
2041
2042     if (!print_stats && !is_last_report && !progress_avio)
2043         return;
2044
2045     if (!is_last_report) {
2046         if (last_time == -1) {
2047             last_time = cur_time;
2048             return;
2049         }
2050         if ((cur_time - last_time) < 500000)
2051             return;
2052         last_time = cur_time;
2053     }
2054
2055
2056     oc = output_files[0]->ctx;
2057
2058     total_size = avio_size(oc->pb);
2059     if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2060         total_size = avio_tell(oc->pb);
2061         if (total_size < 0)
2062             total_size = 0;
2063     }
2064
2065     buf[0] = '\0';
2066     vid = 0;
2067     av_bprint_init(&buf_script, 0, 1);
2068     for (i = 0; i < nb_output_streams; i++) {
2069         float q = -1;
2070         ost = output_streams[i];
2071         enc = ost->st->codec;
2072         if (!ost->stream_copy && enc->coded_frame)
2073             q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2074         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2075             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2076             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
2077                        ost->file_index, ost->index, q);
2078         }
2079         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2080             float fps, t = (cur_time-timer_start) / 1000000.0;
2081
2082             frame_number = ost->frame_number;
2083             fps = t > 1 ? frame_number / t : 0;
2084             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2085                      frame_number, fps < 9.95, fps, q);
2086             av_bprintf(&buf_script, "frame=%d\n", frame_number);
2087             av_bprintf(&buf_script, "fps=%.1f\n", fps);
2088             av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
2089                        ost->file_index, ost->index, q);
2090             if (is_last_report)
2091                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2092             if (qp_hist) {
2093                 int j;
2094                 int qp = lrintf(q);
2095                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2096                     qp_histogram[qp]++;
2097                 for (j = 0; j < 32; j++)
2098                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2099             }
2100             if (enc->flags&CODEC_FLAG_PSNR) {
2101                 int j;
2102                 double error, error_sum = 0;
2103                 double scale, scale_sum = 0;
2104                 double p;
2105                 char type[3] = { 'Y','U','V' };
2106                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2107                 for (j = 0; j < 3; j++) {
2108                     if (is_last_report) {
2109                         error = enc->error[j];
2110                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2111                     } else {
2112                         error = enc->coded_frame->error[j];
2113                         scale = enc->width * enc->height * 255.0 * 255.0;
2114                     }
2115                     if (j)
2116                         scale /= 4;
2117                     error_sum += error;
2118                     scale_sum += scale;
2119                     p = psnr(error / scale);
2120                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], p);
2121                     av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
2122                                ost->file_index, ost->index, type[i] | 32, p);
2123                 }
2124                 p = psnr(error_sum / scale_sum);
2125                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2126                 av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
2127                            ost->file_index, ost->index, p);
2128             }
2129             vid = 1;
2130         }
2131         /* compute min output value */
2132         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2133                                       ost->st->time_base, AV_TIME_BASE_Q));
2134     }
2135
2136     secs = pts / AV_TIME_BASE;
2137     us = pts % AV_TIME_BASE;
2138     mins = secs / 60;
2139     secs %= 60;
2140     hours = mins / 60;
2141     mins %= 60;
2142
2143     bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2144
2145     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2146              "size=%8.0fkB time=", total_size / 1024.0);
2147     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2148              "%02d:%02d:%02d.%02d ", hours, mins, secs,
2149              (100 * us) / AV_TIME_BASE);
2150     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2151              "bitrate=%6.1fkbits/s", bitrate);
2152     av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
2153     av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
2154     av_bprintf(&buf_script, "out_time=%02d:%02d:%02d.%06d\n",
2155                hours, mins, secs, us);
2156
2157     if (nb_frames_dup || nb_frames_drop)
2158         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2159                 nb_frames_dup, nb_frames_drop);
2160     av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
2161     av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
2162
2163     if (print_stats || is_last_report) {
2164     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
2165
2166     fflush(stderr);
2167     }
2168
2169     if (progress_avio) {
2170         av_bprintf(&buf_script, "progress=%s\n",
2171                    is_last_report ? "end" : "continue");
2172         avio_write(progress_avio, buf_script.str,
2173                    FFMIN(buf_script.len, buf_script.size - 1));
2174         avio_flush(progress_avio);
2175         av_bprint_finalize(&buf_script, NULL);
2176         if (is_last_report) {
2177             avio_close(progress_avio);
2178             progress_avio = NULL;
2179         }
2180     }
2181
2182     if (is_last_report) {
2183         int64_t raw= audio_size + video_size + subtitle_size + extra_size;
2184         av_log(NULL, AV_LOG_INFO, "\n");
2185         av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0f global headers:%1.0fkB muxing overhead %f%%\n",
2186                video_size / 1024.0,
2187                audio_size / 1024.0,
2188                subtitle_size / 1024.0,
2189                extra_size / 1024.0,
2190                100.0 * (total_size - raw) / raw
2191         );
2192         if(video_size + audio_size + subtitle_size + extra_size == 0){
2193             av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2194         }
2195     }
2196 }
2197
2198 static void flush_encoders(void)
2199 {
2200     int i, ret;
2201
2202     for (i = 0; i < nb_output_streams; i++) {
2203         OutputStream   *ost = output_streams[i];
2204         AVCodecContext *enc = ost->st->codec;
2205         AVFormatContext *os = output_files[ost->file_index]->ctx;
2206         int stop_encoding = 0;
2207
2208         if (!ost->encoding_needed)
2209             continue;
2210
2211         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2212             continue;
2213         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2214             continue;
2215
2216         for (;;) {
2217             int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
2218             const char *desc;
2219             int64_t *size;
2220
2221             switch (ost->st->codec->codec_type) {
2222             case AVMEDIA_TYPE_AUDIO:
2223                 encode = avcodec_encode_audio2;
2224                 desc   = "Audio";
2225                 size   = &audio_size;
2226                 break;
2227             case AVMEDIA_TYPE_VIDEO:
2228                 encode = avcodec_encode_video2;
2229                 desc   = "Video";
2230                 size   = &video_size;
2231                 break;
2232             default:
2233                 stop_encoding = 1;
2234             }
2235
2236             if (encode) {
2237                 AVPacket pkt;
2238                 int got_packet;
2239                 av_init_packet(&pkt);
2240                 pkt.data = NULL;
2241                 pkt.size = 0;
2242
2243                 update_benchmark(NULL);
2244                 ret = encode(enc, &pkt, NULL, &got_packet);
2245                 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
2246                 if (ret < 0) {
2247                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
2248                     exit_program(1);
2249                 }
2250                 *size += pkt.size;
2251                 if (ost->logfile && enc->stats_out) {
2252                     fprintf(ost->logfile, "%s", enc->stats_out);
2253                 }
2254                 if (!got_packet) {
2255                     stop_encoding = 1;
2256                     break;
2257                 }
2258                 if (pkt.pts != AV_NOPTS_VALUE)
2259                     pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2260                 if (pkt.dts != AV_NOPTS_VALUE)
2261                     pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2262                 write_frame(os, &pkt, ost);
2263             }
2264
2265             if (stop_encoding)
2266                 break;
2267         }
2268     }
2269 }
2270
2271 /*
2272  * Check whether a packet from ist should be written into ost at this time
2273  */
2274 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2275 {
2276     OutputFile *of = output_files[ost->file_index];
2277     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
2278
2279     if (ost->source_index != ist_index)
2280         return 0;
2281
2282     if (of->start_time && ist->pts < of->start_time)
2283         return 0;
2284
2285     return 1;
2286 }
2287
2288 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2289 {
2290     OutputFile *of = output_files[ost->file_index];
2291     int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2292     AVPicture pict;
2293     AVPacket opkt;
2294
2295     av_init_packet(&opkt);
2296
2297     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2298         !ost->copy_initial_nonkeyframes)
2299         return;
2300
2301     if (of->recording_time != INT64_MAX &&
2302         ist->pts >= of->recording_time + of->start_time) {
2303         ost->is_past_recording_time = 1;
2304         return;
2305     }
2306
2307     /* force the input stream PTS */
2308     if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2309         audio_size += pkt->size;
2310     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2311         video_size += pkt->size;
2312         ost->sync_opts++;
2313     } else if (ost->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2314         subtitle_size += pkt->size;
2315     }
2316
2317     if (pkt->pts != AV_NOPTS_VALUE)
2318         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2319     else
2320         opkt.pts = AV_NOPTS_VALUE;
2321
2322     if (pkt->dts == AV_NOPTS_VALUE)
2323         opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2324     else
2325         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2326     opkt.dts -= ost_tb_start_time;
2327
2328     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2329     opkt.flags    = pkt->flags;
2330
2331     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2332     if (  ost->st->codec->codec_id != CODEC_ID_H264
2333        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2334        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2335        && ost->st->codec->codec_id != CODEC_ID_VC1
2336        ) {
2337         if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2338             opkt.destruct = av_destruct_packet;
2339     } else {
2340         opkt.data = pkt->data;
2341         opkt.size = pkt->size;
2342     }
2343     if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2344         /* store AVPicture in AVPacket, as expected by the output format */
2345         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2346         opkt.data = (uint8_t *)&pict;
2347         opkt.size = sizeof(AVPicture);
2348         opkt.flags |= AV_PKT_FLAG_KEY;
2349     }
2350
2351     write_frame(of->ctx, &opkt, ost);
2352     ost->st->codec->frame_number++;
2353     av_free_packet(&opkt);
2354 }
2355
2356 static void rate_emu_sleep(InputStream *ist)
2357 {
2358     if (input_files[ist->file_index]->rate_emu) {
2359         int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2360         int64_t now = av_gettime() - ist->start;
2361         if (pts > now)
2362             av_usleep(pts - now);
2363     }
2364 }
2365
2366 static int guess_input_channel_layout(InputStream *ist)
2367 {
2368     AVCodecContext *dec = ist->st->codec;
2369
2370     if (!dec->channel_layout) {
2371         char layout_name[256];
2372
2373         dec->channel_layout = av_get_default_channel_layout(dec->channels);
2374         if (!dec->channel_layout)
2375             return 0;
2376         av_get_channel_layout_string(layout_name, sizeof(layout_name),
2377                                      dec->channels, dec->channel_layout);
2378         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for  Input Stream "
2379                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2380     }
2381     return 1;
2382 }
2383
2384 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2385 {
2386     AVFrame *decoded_frame;
2387     AVCodecContext *avctx = ist->st->codec;
2388     int i, ret, resample_changed;
2389
2390     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2391         return AVERROR(ENOMEM);
2392     else
2393         avcodec_get_frame_defaults(ist->decoded_frame);
2394     decoded_frame = ist->decoded_frame;
2395     av_codec_set_pkt_timebase(avctx, ist->st->time_base);
2396
2397     update_benchmark(NULL);
2398     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2399     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2400     if (ret < 0) {
2401         return ret;
2402     }
2403     if (avctx->sample_rate <= 0) {
2404         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2405         return AVERROR_INVALIDDATA;
2406     }
2407
2408     if (!*got_output) {
2409         /* no audio frame */
2410         if (!pkt->size)
2411             for (i = 0; i < ist->nb_filters; i++)
2412                 av_buffersrc_add_ref(ist->filters[i]->filter, NULL,
2413                                      AV_BUFFERSRC_FLAG_NO_COPY);
2414         return ret;
2415     }
2416
2417     /* if the decoder provides a pts, use it instead of the last packet pts.
2418        the decoder could be delaying output by a packet or more. */
2419     if (decoded_frame->pts != AV_NOPTS_VALUE)
2420         ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2421     else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
2422         decoded_frame->pts = decoded_frame->pkt_pts;
2423         pkt->pts           = AV_NOPTS_VALUE;
2424     } else if (pkt->pts != AV_NOPTS_VALUE) {
2425         decoded_frame->pts = pkt->pts;
2426         pkt->pts           = AV_NOPTS_VALUE;
2427     }else
2428         decoded_frame->pts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2429
2430
2431 #if 1
2432     /* increment next_dts to use for the case where the input stream does not
2433        have timestamps or there are multiple frames in the packet */
2434     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2435                      avctx->sample_rate;
2436     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2437                      avctx->sample_rate;
2438 #endif
2439
2440     rate_emu_sleep(ist);
2441
2442     resample_changed = ist->resample_sample_fmt     != decoded_frame->format         ||
2443                        ist->resample_channels       != avctx->channels               ||
2444                        ist->resample_channel_layout != decoded_frame->channel_layout ||
2445                        ist->resample_sample_rate    != decoded_frame->sample_rate;
2446     if (resample_changed) {
2447         char layout1[64], layout2[64];
2448
2449         if (!guess_input_channel_layout(ist)) {
2450             av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2451                    "layout for Input Stream #%d.%d\n", ist->file_index,
2452                    ist->st->index);
2453             exit_program(1);
2454         }
2455         decoded_frame->channel_layout = avctx->channel_layout;
2456
2457         av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2458                                      ist->resample_channel_layout);
2459         av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2460                                      decoded_frame->channel_layout);
2461
2462         av_log(NULL, AV_LOG_INFO,
2463                "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
2464                ist->file_index, ist->st->index,
2465                ist->resample_sample_rate,  av_get_sample_fmt_name(ist->resample_sample_fmt),
2466                ist->resample_channels, layout1,
2467                decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2468                avctx->channels, layout2);
2469
2470         ist->resample_sample_fmt     = decoded_frame->format;
2471         ist->resample_sample_rate    = decoded_frame->sample_rate;
2472         ist->resample_channel_layout = decoded_frame->channel_layout;
2473         ist->resample_channels       = avctx->channels;
2474
2475         for (i = 0; i < nb_filtergraphs; i++)
2476             if (ist_in_filtergraph(filtergraphs[i], ist)) {
2477                 FilterGraph *fg = filtergraphs[i];
2478                 int j;
2479                 if (configure_filtergraph(fg) < 0) {
2480                     av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2481                     exit_program(1);
2482                 }
2483                 for (j = 0; j < fg->nb_outputs; j++) {
2484                     OutputStream *ost = fg->outputs[j]->ost;
2485                     if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2486                         !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
2487                         av_buffersink_set_frame_size(ost->filter->filter,
2488                                                      ost->st->codec->frame_size);
2489                 }
2490             }
2491     }
2492
2493     if (decoded_frame->pts != AV_NOPTS_VALUE)
2494         decoded_frame->pts = av_rescale_q(decoded_frame->pts,
2495                                           ist->st->time_base,
2496                                           (AVRational){1, ist->st->codec->sample_rate});
2497     for (i = 0; i < ist->nb_filters; i++)
2498         av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
2499
2500     return ret;
2501 }
2502
2503 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2504 {
2505     AVFrame *decoded_frame;
2506     void *buffer_to_free = NULL;
2507     int i, ret = 0, resample_changed;
2508     int64_t best_effort_timestamp;
2509     AVRational *frame_sample_aspect;
2510     float quality;
2511
2512     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2513         return AVERROR(ENOMEM);
2514     else
2515         avcodec_get_frame_defaults(ist->decoded_frame);
2516     decoded_frame = ist->decoded_frame;
2517     pkt->dts  = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2518     av_codec_set_pkt_timebase(ist->st->codec, ist->st->time_base);
2519
2520     update_benchmark(NULL);
2521     ret = avcodec_decode_video2(ist->st->codec,
2522                                 decoded_frame, got_output, pkt);
2523     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2524     if (ret < 0)
2525         return ret;
2526
2527     quality = same_quant ? decoded_frame->quality : 0;
2528     if (!*got_output) {
2529         /* no picture yet */
2530         if (!pkt->size)
2531             for (i = 0; i < ist->nb_filters; i++)
2532                 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, AV_BUFFERSRC_FLAG_NO_COPY);
2533         return ret;
2534     }
2535
2536     if(ist->top_field_first>=0)
2537         decoded_frame->top_field_first = ist->top_field_first;
2538
2539     best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2540     if(best_effort_timestamp != AV_NOPTS_VALUE)
2541         ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2542
2543     if (debug_ts) {
2544         av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2545                 "frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64" best_effort_ts_time:%s keyframe:%d frame_type:%d \n",
2546                 ist->st->index, av_ts2str(decoded_frame->pts),
2547                 av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2548                 best_effort_timestamp,
2549                 av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2550                 decoded_frame->key_frame, decoded_frame->pict_type);
2551     }
2552
2553     pkt->size = 0;
2554     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2555
2556     rate_emu_sleep(ist);
2557
2558     if (ist->st->sample_aspect_ratio.num)
2559         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2560
2561     resample_changed = ist->resample_width   != decoded_frame->width  ||
2562                        ist->resample_height  != decoded_frame->height ||
2563                        ist->resample_pix_fmt != decoded_frame->format;
2564     if (resample_changed) {
2565         av_log(NULL, AV_LOG_INFO,
2566                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2567                ist->file_index, ist->st->index,
2568                ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
2569                decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2570
2571         ist->resample_width   = decoded_frame->width;
2572         ist->resample_height  = decoded_frame->height;
2573         ist->resample_pix_fmt = decoded_frame->format;
2574
2575         for (i = 0; i < nb_filtergraphs; i++)
2576             if (ist_in_filtergraph(filtergraphs[i], ist) &&
2577                 configure_filtergraph(filtergraphs[i]) < 0) {
2578                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2579                 exit_program(1);
2580             }
2581     }
2582
2583     frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2584     for (i = 0; i < ist->nb_filters; i++) {
2585         int changed =      ist->st->codec->width   != ist->filters[i]->filter->outputs[0]->w
2586                         || ist->st->codec->height  != ist->filters[i]->filter->outputs[0]->h
2587                         || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2588         // XXX what an ugly hack
2589         if (ist->filters[i]->graph->nb_outputs == 1)
2590             ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2591
2592         if (!frame_sample_aspect->num)
2593             *frame_sample_aspect = ist->st->sample_aspect_ratio;
2594         if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2595             FrameBuffer      *buf = decoded_frame->opaque;
2596             AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2597                                         decoded_frame->data, decoded_frame->linesize,
2598                                         AV_PERM_READ | AV_PERM_PRESERVE,
2599                                         ist->st->codec->width, ist->st->codec->height,
2600                                         ist->st->codec->pix_fmt);
2601
2602             avfilter_copy_frame_props(fb, decoded_frame);
2603             fb->buf->priv           = buf;
2604             fb->buf->free           = filter_release_buffer;
2605
2606             av_assert0(buf->refcount>0);
2607             buf->refcount++;
2608             av_buffersrc_add_ref(ist->filters[i]->filter, fb,
2609                                  AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
2610                                  AV_BUFFERSRC_FLAG_NO_COPY);
2611         } else
2612         if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
2613             av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2614             exit_program(1);
2615         }
2616
2617     }
2618
2619     av_free(buffer_to_free);
2620     return ret;
2621 }
2622
2623 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2624 {
2625     AVSubtitle subtitle;
2626     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2627                                           &subtitle, got_output, pkt);
2628     if (ret < 0)
2629         return ret;
2630     if (!*got_output)
2631         return ret;
2632
2633     rate_emu_sleep(ist);
2634
2635     for (i = 0; i < nb_output_streams; i++) {
2636         OutputStream *ost = output_streams[i];
2637
2638         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2639             continue;
2640
2641         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2642     }
2643
2644     avsubtitle_free(&subtitle);
2645     return ret;
2646 }
2647
2648 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2649 static int output_packet(InputStream *ist, const AVPacket *pkt)
2650 {
2651     int ret = 0, i;
2652     int got_output;
2653
2654     AVPacket avpkt;
2655     if (!ist->saw_first_ts) {
2656         ist->dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2657         ist->pts = 0;
2658         if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2659             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2660             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2661         }
2662         ist->saw_first_ts = 1;
2663     }
2664
2665     if (ist->next_dts == AV_NOPTS_VALUE)
2666         ist->next_dts = ist->dts;
2667     if (ist->next_pts == AV_NOPTS_VALUE)
2668         ist->next_pts = ist->pts;
2669
2670     if (pkt == NULL) {
2671         /* EOF handling */
2672         av_init_packet(&avpkt);
2673         avpkt.data = NULL;
2674         avpkt.size = 0;
2675         goto handle_eof;
2676     } else {
2677         avpkt = *pkt;
2678     }
2679
2680     if (pkt->dts != AV_NOPTS_VALUE) {
2681         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2682         if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2683             ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2684     }
2685
2686     // while we have more to decode or while the decoder did output something on EOF
2687     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2688         int duration;
2689     handle_eof:
2690
2691         ist->pts = ist->next_pts;
2692         ist->dts = ist->next_dts;
2693
2694         if (avpkt.size && avpkt.size != pkt->size) {
2695             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2696                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2697             ist->showed_multi_packet_warning = 1;
2698         }
2699
2700         switch (ist->st->codec->codec_type) {
2701         case AVMEDIA_TYPE_AUDIO:
2702             ret = decode_audio    (ist, &avpkt, &got_output);
2703             break;
2704         case AVMEDIA_TYPE_VIDEO:
2705             ret = decode_video    (ist, &avpkt, &got_output);
2706             if (avpkt.duration) {
2707                 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2708             } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2709                 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2710                 duration = ((int64_t)AV_TIME_BASE *
2711                                 ist->st->codec->time_base.num * ticks) /
2712                                 ist->st->codec->time_base.den;
2713             } else
2714                 duration = 0;
2715
2716             if(ist->dts != AV_NOPTS_VALUE && duration) {
2717                 ist->next_dts += duration;
2718             }else
2719                 ist->next_dts = AV_NOPTS_VALUE;
2720
2721             if (got_output)
2722                 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2723             break;
2724         case AVMEDIA_TYPE_SUBTITLE:
2725             ret = transcode_subtitles(ist, &avpkt, &got_output);
2726             break;
2727         default:
2728             return -1;
2729         }
2730
2731         if (ret < 0)
2732             return ret;
2733
2734         avpkt.dts=
2735         avpkt.pts= AV_NOPTS_VALUE;
2736
2737         // touch data and size only if not EOF
2738         if (pkt) {
2739             if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2740                 ret = avpkt.size;
2741             avpkt.data += ret;
2742             avpkt.size -= ret;
2743         }
2744         if (!got_output) {
2745             continue;
2746         }
2747     }
2748
2749     /* handle stream copy */
2750     if (!ist->decoding_needed) {
2751         rate_emu_sleep(ist);
2752         ist->dts = ist->next_dts;
2753         switch (ist->st->codec->codec_type) {
2754         case AVMEDIA_TYPE_AUDIO:
2755             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2756                              ist->st->codec->sample_rate;
2757             break;
2758         case AVMEDIA_TYPE_VIDEO:
2759             if (pkt->duration) {
2760                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2761             } else if(ist->st->codec->time_base.num != 0) {
2762                 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2763                 ist->next_dts += ((int64_t)AV_TIME_BASE *
2764                                   ist->st->codec->time_base.num * ticks) /
2765                                   ist->st->codec->time_base.den;
2766             }
2767             break;
2768         }
2769         ist->pts = ist->dts;
2770         ist->next_pts = ist->next_dts;
2771     }
2772     for (i = 0; pkt && i < nb_output_streams; i++) {
2773         OutputStream *ost = output_streams[i];
2774
2775         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2776             continue;
2777
2778         do_streamcopy(ist, ost, pkt);
2779     }
2780
2781     return 0;
2782 }
2783
2784 static void print_sdp(void)
2785 {
2786     char sdp[2048];
2787     int i;
2788     AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2789
2790     if (!avc)
2791         exit_program(1);
2792     for (i = 0; i < nb_output_files; i++)
2793         avc[i] = output_files[i]->ctx;
2794
2795     av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2796     printf("SDP:\n%s\n", sdp);
2797     fflush(stdout);
2798     av_freep(&avc);
2799 }
2800
2801 static int init_input_stream(int ist_index, char *error, int error_len)
2802 {
2803     InputStream *ist = input_streams[ist_index];
2804
2805     if (ist->decoding_needed) {
2806         AVCodec *codec = ist->dec;
2807         if (!codec) {
2808             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2809                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2810             return AVERROR(EINVAL);
2811         }
2812
2813         ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
2814         if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2815             ist->st->codec->get_buffer     = codec_get_buffer;
2816             ist->st->codec->release_buffer = codec_release_buffer;
2817             ist->st->codec->opaque         = &ist->buffer_pool;
2818         }
2819
2820         if (!av_dict_get(ist->opts, "threads", NULL, 0))
2821             av_dict_set(&ist->opts, "threads", "auto", 0);
2822         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2823             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2824                     ist->file_index, ist->st->index);
2825             return AVERROR(EINVAL);
2826         }
2827         assert_codec_experimental(ist->st->codec, 0);
2828         assert_avoptions(ist->opts);
2829     }
2830
2831     ist->next_pts = AV_NOPTS_VALUE;
2832     ist->next_dts = AV_NOPTS_VALUE;
2833     ist->is_start = 1;
2834
2835     return 0;
2836 }
2837
2838 static InputStream *get_input_stream(OutputStream *ost)
2839 {
2840     if (ost->source_index >= 0)
2841         return input_streams[ost->source_index];
2842     return NULL;
2843 }
2844
2845 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2846                                     AVCodecContext *avctx)
2847 {
2848     char *p;
2849     int n = 1, i;
2850     int64_t t;
2851
2852     for (p = kf; *p; p++)
2853         if (*p == ',')
2854             n++;
2855     ost->forced_kf_count = n;
2856     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2857     if (!ost->forced_kf_pts) {
2858         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2859         exit_program(1);
2860     }
2861
2862     p = kf;
2863     for (i = 0; i < n; i++) {
2864         char *next = strchr(p, ',');
2865
2866         if (next)
2867             *next++ = 0;
2868
2869         t = parse_time_or_die("force_key_frames", p, 1);
2870         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2871
2872         p = next;
2873     }
2874 }
2875
2876 static int transcode_init(void)
2877 {
2878     int ret = 0, i, j, k;
2879     AVFormatContext *oc;
2880     AVCodecContext *codec, *icodec = NULL;
2881     OutputStream *ost;
2882     InputStream *ist;
2883     char error[1024];
2884     int want_sdp = 1;
2885
2886     /* init framerate emulation */
2887     for (i = 0; i < nb_input_files; i++) {
2888         InputFile *ifile = input_files[i];
2889         if (ifile->rate_emu)
2890             for (j = 0; j < ifile->nb_streams; j++)
2891                 input_streams[j + ifile->ist_index]->start = av_gettime();
2892     }
2893
2894     /* output stream init */
2895     for (i = 0; i < nb_output_files; i++) {
2896         oc = output_files[i]->ctx;
2897         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2898             av_dump_format(oc, i, oc->filename, 1);
2899             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2900             return AVERROR(EINVAL);
2901         }
2902     }
2903
2904     /* init complex filtergraphs */
2905     for (i = 0; i < nb_filtergraphs; i++)
2906         if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2907             return ret;
2908
2909     /* for each output stream, we compute the right encoding parameters */
2910     for (i = 0; i < nb_output_streams; i++) {
2911         ost = output_streams[i];
2912         oc  = output_files[ost->file_index]->ctx;
2913         ist = get_input_stream(ost);
2914
2915         if (ost->attachment_filename)
2916             continue;
2917
2918         codec  = ost->st->codec;
2919
2920         if (ist) {
2921             icodec = ist->st->codec;
2922
2923             ost->st->disposition          = ist->st->disposition;
2924             codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
2925             codec->chroma_sample_location = icodec->chroma_sample_location;
2926         }
2927
2928         if (ost->stream_copy) {
2929             uint64_t extra_size;
2930
2931             av_assert0(ist && !ost->filter);
2932
2933             extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2934
2935             if (extra_size > INT_MAX) {
2936                 return AVERROR(EINVAL);
2937             }
2938
2939             /* if stream_copy is selected, no need to decode or encode */
2940             codec->codec_id   = icodec->codec_id;
2941             codec->codec_type = icodec->codec_type;
2942
2943             if (!codec->codec_tag) {
2944                 if (!oc->oformat->codec_tag ||
2945                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2946                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2947                     codec->codec_tag = icodec->codec_tag;
2948             }
2949
2950             codec->bit_rate       = icodec->bit_rate;
2951             codec->rc_max_rate    = icodec->rc_max_rate;
2952             codec->rc_buffer_size = icodec->rc_buffer_size;
2953             codec->field_order    = icodec->field_order;
2954             codec->extradata      = av_mallocz(extra_size);
2955             if (!codec->extradata) {
2956                 return AVERROR(ENOMEM);
2957             }
2958             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2959             codec->extradata_size= icodec->extradata_size;
2960             codec->bits_per_coded_sample  = icodec->bits_per_coded_sample;
2961
2962             codec->time_base = ist->st->time_base;
2963             /*
2964              * Avi is a special case here because it supports variable fps but
2965              * having the fps and timebase differe significantly adds quite some
2966              * overhead
2967              */
2968             if(!strcmp(oc->oformat->name, "avi")) {
2969                 if (   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2970                                  && av_q2d(ist->st->time_base) < 1.0/500
2971                     || copy_tb==0){
2972                     codec->time_base = icodec->time_base;
2973                     codec->time_base.num *= icodec->ticks_per_frame;
2974                     codec->time_base.den *= 2;
2975                     codec->ticks_per_frame = 2;
2976                 }
2977             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2978                       && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2979                       && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2980             ) {
2981                 if(   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2982                                 && av_q2d(ist->st->time_base) < 1.0/500
2983                    || copy_tb==0){
2984                     codec->time_base = icodec->time_base;
2985                     codec->time_base.num *= icodec->ticks_per_frame;
2986                 }
2987             }
2988
2989             if(ost->frame_rate.num)
2990                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2991
2992             av_reduce(&codec->time_base.num, &codec->time_base.den,
2993                         codec->time_base.num, codec->time_base.den, INT_MAX);
2994
2995             switch (codec->codec_type) {
2996             case AVMEDIA_TYPE_AUDIO:
2997                 if (audio_volume != 256) {
2998                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2999                     exit_program(1);
3000                 }
3001                 codec->channel_layout     = icodec->channel_layout;
3002                 codec->sample_rate        = icodec->sample_rate;
3003                 codec->channels           = icodec->channels;
3004                 codec->frame_size         = icodec->frame_size;
3005                 codec->audio_service_type = icodec->audio_service_type;
3006                 codec->block_align        = icodec->block_align;
3007                 if((codec->block_align == 1 || codec->block_align == 1152) && codec->codec_id == CODEC_ID_MP3)
3008                     codec->block_align= 0;
3009                 if(codec->codec_id == CODEC_ID_AC3)
3010                     codec->block_align= 0;
3011                 break;
3012             case AVMEDIA_TYPE_VIDEO:
3013                 codec->pix_fmt            = icodec->pix_fmt;
3014                 codec->width              = icodec->width;
3015                 codec->height             = icodec->height;
3016                 codec->has_b_frames       = icodec->has_b_frames;
3017                 if (!codec->sample_aspect_ratio.num) {
3018                     codec->sample_aspect_ratio   =
3019                     ost->st->sample_aspect_ratio =
3020                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
3021                         ist->st->codec->sample_aspect_ratio.num ?
3022                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3023                 }
3024                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3025                 break;
3026             case AVMEDIA_TYPE_SUBTITLE:
3027                 codec->width  = icodec->width;
3028                 codec->height = icodec->height;
3029                 break;
3030             case AVMEDIA_TYPE_DATA:
3031             case AVMEDIA_TYPE_ATTACHMENT:
3032                 break;
3033             default:
3034                 abort();
3035             }
3036         } else {
3037             if (!ost->enc)
3038                 ost->enc = avcodec_find_encoder(codec->codec_id);
3039             if (!ost->enc) {
3040                 /* should only happen when a default codec is not present. */
3041                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3042                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3043                 ret = AVERROR(EINVAL);
3044                 goto dump_format;
3045             }
3046
3047             if (ist)
3048                 ist->decoding_needed = 1;
3049             ost->encoding_needed = 1;
3050
3051             if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3052                 if (ost->filter && !ost->frame_rate.num)
3053                     ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3054                 if (ist && !ost->frame_rate.num)
3055                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
3056                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3057                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3058                     ost->frame_rate = ost->enc->supported_framerates[idx];
3059                 }
3060             }
3061
3062             if (!ost->filter &&
3063                 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3064                  codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
3065                     FilterGraph *fg;
3066                     fg = init_simple_filtergraph(ist, ost);
3067                     if (configure_filtergraph(fg)) {
3068                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3069                         exit(1);
3070                     }
3071             }
3072
3073             switch (codec->codec_type) {
3074             case AVMEDIA_TYPE_AUDIO:
3075                 codec->sample_fmt     = ost->filter->filter->inputs[0]->format;
3076                 codec->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
3077                 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3078                 codec->channels       = av_get_channel_layout_nb_channels(codec->channel_layout);
3079                 codec->time_base      = (AVRational){ 1, codec->sample_rate };
3080                 break;
3081             case AVMEDIA_TYPE_VIDEO:
3082                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3083                 if (ost->filter && !(codec->time_base.num && codec->time_base.den))
3084                     codec->time_base = ost->filter->filter->inputs[0]->time_base;
3085                 if (   av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3086                    && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3087                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3088                                                "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3089                 }
3090                 for (j = 0; j < ost->forced_kf_count; j++)
3091                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3092                                                          AV_TIME_BASE_Q,
3093                                                          codec->time_base);
3094
3095                 codec->width  = ost->filter->filter->inputs[0]->w;
3096                 codec->height = ost->filter->filter->inputs[0]->h;
3097                 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3098                     ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3099                     av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3100                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
3101                 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3102
3103                 if (!icodec ||
3104                     codec->width   != icodec->width  ||
3105                     codec->height  != icodec->height ||
3106                     codec->pix_fmt != icodec->pix_fmt) {
3107                     codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3108                 }
3109
3110                 if (ost->forced_keyframes)
3111                     parse_forced_key_frames(ost->forced_keyframes, ost,
3112                                             ost->st->codec);
3113                 break;
3114             case AVMEDIA_TYPE_SUBTITLE:
3115                 codec->time_base = (AVRational){1, 1000};
3116                 break;
3117             default:
3118                 abort();
3119                 break;
3120             }
3121             /* two pass mode */
3122             if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3123                 char logfilename[1024];
3124                 FILE *f;
3125
3126                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3127                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3128                          i);
3129                 if (!strcmp(ost->enc->name, "libx264")) {
3130                     av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3131                 } else {
3132                     if (codec->flags & CODEC_FLAG_PASS2) {
3133                         char  *logbuffer;
3134                         size_t logbuffer_size;
3135                         if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3136                             av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3137                                    logfilename);
3138                             exit_program(1);
3139                         }
3140                         codec->stats_in = logbuffer;
3141                     }
3142                     if (codec->flags & CODEC_FLAG_PASS1) {
3143                         f = fopen(logfilename, "wb");
3144                         if (!f) {
3145                             av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3146                                 logfilename, strerror(errno));
3147                             exit_program(1);
3148                         }
3149                         ost->logfile = f;
3150                     }
3151                 }
3152             }
3153         }
3154     }
3155
3156     /* open each encoder */
3157     for (i = 0; i < nb_output_streams; i++) {
3158         ost = output_streams[i];
3159         if (ost->encoding_needed) {
3160             AVCodec      *codec = ost->enc;
3161             AVCodecContext *dec = NULL;
3162
3163             if ((ist = get_input_stream(ost)))
3164                 dec = ist->st->codec;
3165             if (dec && dec->subtitle_header) {
3166                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3167                 if (!ost->st->codec->subtitle_header) {
3168                     ret = AVERROR(ENOMEM);
3169                     goto dump_format;
3170                 }
3171                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3172                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3173             }
3174             if (!av_dict_get(ost->opts, "threads", NULL, 0))
3175                 av_dict_set(&ost->opts, "threads", "auto", 0);
3176             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3177                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3178                         ost->file_index, ost->index);
3179                 ret = AVERROR(EINVAL);
3180                 goto dump_format;
3181             }
3182             if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3183                 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
3184                 av_buffersink_set_frame_size(ost->filter->filter,
3185                                              ost->st->codec->frame_size);
3186             assert_codec_experimental(ost->st->codec, 1);
3187             assert_avoptions(ost->opts);
3188             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3189                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3190                                              " It takes bits/s as argument, not kbits/s\n");
3191             extra_size += ost->st->codec->extradata_size;
3192
3193             if (ost->st->codec->me_threshold)
3194                 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3195         }
3196     }
3197
3198     /* init input streams */
3199     for (i = 0; i < nb_input_streams; i++)
3200         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3201             goto dump_format;
3202
3203     /* discard unused programs */
3204     for (i = 0; i < nb_input_files; i++) {
3205         InputFile *ifile = input_files[i];
3206         for (j = 0; j < ifile->ctx->nb_programs; j++) {
3207             AVProgram *p = ifile->ctx->programs[j];
3208             int discard  = AVDISCARD_ALL;
3209
3210             for (k = 0; k < p->nb_stream_indexes; k++)
3211                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3212                     discard = AVDISCARD_DEFAULT;
3213                     break;
3214                 }
3215             p->discard = discard;
3216         }
3217     }
3218
3219     /* open files and write file headers */
3220     for (i = 0; i < nb_output_files; i++) {
3221         oc = output_files[i]->ctx;
3222         oc->interrupt_callback = int_cb;
3223         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3224             char errbuf[128];
3225             const char *errbuf_ptr = errbuf;
3226             if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
3227                 errbuf_ptr = strerror(AVUNERROR(ret));
3228             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
3229             ret = AVERROR(EINVAL);
3230             goto dump_format;
3231         }
3232 //         assert_avoptions(output_files[i]->opts);
3233         if (strcmp(oc->oformat->name, "rtp")) {
3234             want_sdp = 0;
3235         }
3236     }
3237
3238  dump_format:
3239     /* dump the file output parameters - cannot be done before in case
3240        of stream copy */
3241     for (i = 0; i < nb_output_files; i++) {
3242         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3243     }
3244
3245     /* dump the stream mapping */
3246     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3247     for (i = 0; i < nb_input_streams; i++) {
3248         ist = input_streams[i];
3249
3250         for (j = 0; j < ist->nb_filters; j++) {
3251             if (ist->filters[j]->graph->graph_desc) {
3252                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
3253                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3254                        ist->filters[j]->name);
3255                 if (nb_filtergraphs > 1)
3256                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3257                 av_log(NULL, AV_LOG_INFO, "\n");
3258             }
3259         }
3260     }
3261
3262     for (i = 0; i < nb_output_streams; i++) {
3263         ost = output_streams[i];
3264
3265         if (ost->attachment_filename) {
3266             /* an attached file */
3267             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
3268                    ost->attachment_filename, ost->file_index, ost->index);
3269             continue;
3270         }
3271
3272         if (ost->filter && ost->filter->graph->graph_desc) {
3273             /* output from a complex graph */
3274             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
3275             if (nb_filtergraphs > 1)
3276                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3277
3278             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3279                    ost->index, ost->enc ? ost->enc->name : "?");
3280             continue;
3281         }
3282
3283         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
3284                input_streams[ost->source_index]->file_index,
3285                input_streams[ost->source_index]->st->index,
3286                ost->file_index,
3287                ost->index);
3288         if (ost->sync_ist != input_streams[ost->source_index])
3289             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3290                    ost->sync_ist->file_index,
3291                    ost->sync_ist->st->index);
3292         if (ost->stream_copy)
3293             av_log(NULL, AV_LOG_INFO, " (copy)");
3294         else
3295             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3296                    input_streams[ost->source_index]->dec->name : "?",
3297                    ost->enc ? ost->enc->name : "?");
3298         av_log(NULL, AV_LOG_INFO, "\n");
3299     }
3300
3301     if (ret) {
3302         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3303         return ret;
3304     }
3305
3306     if (want_sdp) {
3307         print_sdp();
3308     }
3309
3310     return 0;
3311 }
3312
3313 /**
3314  * @return 1 if there are still streams where more output is wanted,
3315  *         0 otherwise
3316  */
3317 static int need_output(void)
3318 {
3319     int i;
3320
3321     for (i = 0; i < nb_output_streams; i++) {
3322         OutputStream *ost    = output_streams[i];
3323         OutputFile *of       = output_files[ost->file_index];
3324         AVFormatContext *os  = output_files[ost->file_index]->ctx;
3325
3326         if (ost->is_past_recording_time ||
3327             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3328             continue;
3329         if (ost->frame_number >= ost->max_frames) {
3330             int j;
3331             for (j = 0; j < of->ctx->nb_streams; j++)
3332                 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3333             continue;
3334         }
3335
3336         return 1;
3337     }
3338
3339     return 0;
3340 }
3341
3342 static int select_input_file(uint8_t *no_packet)
3343 {
3344     int64_t ipts_min = INT64_MAX;
3345     int i, file_index = -1;
3346
3347     for (i = 0; i < nb_input_streams; i++) {
3348         InputStream *ist = input_streams[i];
3349         int64_t ipts     = ist->pts;
3350
3351         if (ist->discard || no_packet[ist->file_index])
3352             continue;
3353         if (!input_files[ist->file_index]->eof_reached) {
3354             if (ipts < ipts_min) {
3355                 ipts_min = ipts;
3356                 file_index = ist->file_index;
3357             }
3358         }
3359     }
3360
3361     return file_index;
3362 }
3363
3364 static int check_keyboard_interaction(int64_t cur_time)
3365 {
3366     int i, ret, key;
3367     static int64_t last_time;
3368     if (received_nb_signals)
3369         return AVERROR_EXIT;
3370     /* read_key() returns 0 on EOF */
3371     if(cur_time - last_time >= 100000 && !run_as_daemon){
3372         key =  read_key();
3373         last_time = cur_time;
3374     }else
3375         key = -1;
3376     if (key == 'q')
3377         return AVERROR_EXIT;
3378     if (key == '+') av_log_set_level(av_log_get_level()+10);
3379     if (key == '-') av_log_set_level(av_log_get_level()-10);
3380     if (key == 's') qp_hist     ^= 1;
3381     if (key == 'h'){
3382         if (do_hex_dump){
3383             do_hex_dump = do_pkt_dump = 0;
3384         } else if(do_pkt_dump){
3385             do_hex_dump = 1;
3386         } else
3387             do_pkt_dump = 1;
3388         av_log_set_level(AV_LOG_DEBUG);
3389     }
3390     if (key == 'c' || key == 'C'){
3391         char buf[4096], target[64], command[256], arg[256] = {0};
3392         double time;
3393         int k, n = 0;
3394         fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3395         i = 0;
3396         while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3397             if (k > 0)
3398                 buf[i++] = k;
3399         buf[i] = 0;
3400         if (k > 0 &&
3401             (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3402             av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3403                    target, time, command, arg);
3404             for (i = 0; i < nb_filtergraphs; i++) {
3405                 FilterGraph *fg = filtergraphs[i];
3406                 if (fg->graph) {
3407                     if (time < 0) {
3408                         ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3409                                                           key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3410                         fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3411                     } else {
3412                         ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3413                     }
3414                 }
3415             }
3416         } else {
3417             av_log(NULL, AV_LOG_ERROR,
3418                    "Parse error, at least 3 arguments were expected, "
3419                    "only %d given in string '%s'\n", n, buf);
3420         }
3421     }
3422     if (key == 'd' || key == 'D'){
3423         int debug=0;
3424         if(key == 'D') {
3425             debug = input_streams[0]->st->codec->debug<<1;
3426             if(!debug) debug = 1;
3427             while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3428                 debug += debug;
3429         }else
3430             if(scanf("%d", &debug)!=1)
3431                 fprintf(stderr,"error parsing debug value\n");
3432         for(i=0;i<nb_input_streams;i++) {
3433             input_streams[i]->st->codec->debug = debug;
3434         }
3435         for(i=0;i<nb_output_streams;i++) {
3436             OutputStream *ost = output_streams[i];
3437             ost->st->codec->debug = debug;
3438         }
3439         if(debug) av_log_set_level(AV_LOG_DEBUG);
3440         fprintf(stderr,"debug=%d\n", debug);
3441     }
3442     if (key == '?'){
3443         fprintf(stderr, "key    function\n"
3444                         "?      show this help\n"
3445                         "+      increase verbosity\n"
3446                         "-      decrease verbosity\n"
3447                         "c      Send command to filtergraph\n"
3448                         "D      cycle through available debug modes\n"
3449                         "h      dump packets/hex press to cycle through the 3 states\n"
3450                         "q      quit\n"
3451                         "s      Show QP histogram\n"
3452         );
3453     }
3454     return 0;
3455 }
3456
3457 #if HAVE_PTHREADS
3458 static void *input_thread(void *arg)
3459 {
3460     InputFile *f = arg;
3461     int ret = 0;
3462
3463     while (!transcoding_finished && ret >= 0) {
3464         AVPacket pkt;
3465         ret = av_read_frame(f->ctx, &pkt);
3466
3467         if (ret == AVERROR(EAGAIN)) {
3468             av_usleep(10000);
3469             ret = 0;
3470             continue;
3471         } else if (ret < 0)
3472             break;
3473
3474         pthread_mutex_lock(&f->fifo_lock);
3475         while (!av_fifo_space(f->fifo))
3476             pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
3477
3478         av_dup_packet(&pkt);
3479         av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
3480
3481         pthread_mutex_unlock(&f->fifo_lock);
3482     }
3483
3484     f->finished = 1;
3485     return NULL;
3486 }
3487
3488 static void free_input_threads(void)
3489 {
3490     int i;
3491
3492     if (nb_input_files == 1)
3493         return;
3494
3495     transcoding_finished = 1;
3496
3497     for (i = 0; i < nb_input_files; i++) {
3498         InputFile *f = input_files[i];
3499         AVPacket pkt;
3500
3501         if (!f->fifo || f->joined)
3502             continue;
3503
3504         pthread_mutex_lock(&f->fifo_lock);
3505         while (av_fifo_size(f->fifo)) {
3506             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3507             av_free_packet(&pkt);
3508         }
3509         pthread_cond_signal(&f->fifo_cond);
3510         pthread_mutex_unlock(&f->fifo_lock);
3511
3512         pthread_join(f->thread, NULL);
3513         f->joined = 1;
3514
3515         while (av_fifo_size(f->fifo)) {
3516             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3517             av_free_packet(&pkt);
3518         }
3519         av_fifo_free(f->fifo);
3520     }
3521 }
3522
3523 static int init_input_threads(void)
3524 {
3525     int i, ret;
3526
3527     if (nb_input_files == 1)
3528         return 0;
3529
3530     for (i = 0; i < nb_input_files; i++) {
3531         InputFile *f = input_files[i];
3532
3533         if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
3534             return AVERROR(ENOMEM);
3535
3536         pthread_mutex_init(&f->fifo_lock, NULL);
3537         pthread_cond_init (&f->fifo_cond, NULL);
3538
3539         if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
3540             return AVERROR(ret);
3541     }
3542     return 0;
3543 }
3544
3545 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
3546 {
3547     int ret = 0;
3548
3549     pthread_mutex_lock(&f->fifo_lock);
3550
3551     if (av_fifo_size(f->fifo)) {
3552         av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
3553         pthread_cond_signal(&f->fifo_cond);
3554     } else {
3555         if (f->finished)
3556             ret = AVERROR_EOF;
3557         else
3558             ret = AVERROR(EAGAIN);
3559     }
3560
3561     pthread_mutex_unlock(&f->fifo_lock);
3562
3563     return ret;
3564 }
3565 #endif
3566
3567 static int get_input_packet(InputFile *f, AVPacket *pkt)
3568 {
3569 #if HAVE_PTHREADS
3570     if (nb_input_files > 1)
3571         return get_input_packet_mt(f, pkt);
3572 #endif
3573     return av_read_frame(f->ctx, pkt);
3574 }
3575
3576 /*
3577  * The following code is the main loop of the file converter
3578  */
3579 static int transcode(void)
3580 {
3581     int ret, i;
3582     AVFormatContext *is, *os;
3583     OutputStream *ost;
3584     InputStream *ist;
3585     uint8_t *no_packet;
3586     int no_packet_count = 0;
3587     int64_t timer_start;
3588
3589     if (!(no_packet = av_mallocz(nb_input_files)))
3590         exit_program(1);
3591
3592     ret = transcode_init();
3593     if (ret < 0)
3594         goto fail;
3595
3596     if (stdin_interaction) {
3597         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3598     }
3599
3600     timer_start = av_gettime();
3601
3602 #if HAVE_PTHREADS
3603     if ((ret = init_input_threads()) < 0)
3604         goto fail;
3605 #endif
3606
3607     for (; received_sigterm == 0;) {
3608         int file_index, ist_index;
3609         AVPacket pkt;
3610         int64_t cur_time= av_gettime();
3611
3612         /* if 'q' pressed, exits */
3613         if (stdin_interaction)
3614             if (check_keyboard_interaction(cur_time) < 0)
3615                 break;
3616
3617         /* check if there's any stream where output is still needed */
3618         if (!need_output()) {
3619             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
3620             break;
3621         }
3622
3623         /* select the stream that we must read now */
3624         file_index = select_input_file(no_packet);
3625         /* if none, if is finished */
3626         if (file_index < 0) {
3627             if (no_packet_count) {
3628                 no_packet_count = 0;
3629                 memset(no_packet, 0, nb_input_files);
3630                 av_usleep(10000);
3631                 continue;
3632             }
3633             av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
3634             break;
3635         }
3636
3637         is  = input_files[file_index]->ctx;
3638         ret = get_input_packet(input_files[file_index], &pkt);
3639
3640         if (ret == AVERROR(EAGAIN)) {
3641             no_packet[file_index] = 1;
3642             no_packet_count++;
3643             continue;
3644         }
3645         if (ret < 0) {
3646             if (ret != AVERROR_EOF) {
3647                 print_error(is->filename, ret);
3648                 if (exit_on_error)
3649                     exit_program(1);
3650             }
3651             input_files[file_index]->eof_reached = 1;
3652
3653             for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3654                 ist = input_streams[input_files[file_index]->ist_index + i];
3655                 if (ist->decoding_needed)
3656                     output_packet(ist, NULL);
3657             }
3658
3659             if (opt_shortest)
3660                 break;
3661             else
3662                 continue;
3663         }
3664
3665         no_packet_count = 0;
3666         memset(no_packet, 0, nb_input_files);
3667
3668         if (do_pkt_dump) {
3669             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3670                              is->streams[pkt.stream_index]);
3671         }
3672         /* the following test is needed in case new streams appear
3673            dynamically in stream : we ignore them */
3674         if (pkt.stream_index >= input_files[file_index]->nb_streams)
3675             goto discard_packet;
3676         ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3677         ist = input_streams[ist_index];
3678         if (ist->discard)
3679             goto discard_packet;
3680
3681         if (pkt.dts != AV_NOPTS_VALUE)
3682             pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3683         if (pkt.pts != AV_NOPTS_VALUE)
3684             pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3685
3686         if (pkt.pts != AV_NOPTS_VALUE)
3687             pkt.pts *= ist->ts_scale;
3688         if (pkt.dts != AV_NOPTS_VALUE)
3689             pkt.dts *= ist->ts_scale;
3690
3691         if (debug_ts) {
3692             av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3693                     "next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s  pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%"PRId64"\n",
3694                     ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3695                     av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3696                     av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3697                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3698                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3699                     input_files[ist->file_index]->ts_offset);
3700         }
3701
3702         if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3703             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3704             int64_t delta   = pkt_dts - ist->next_dts;
3705             if (is->iformat->flags & AVFMT_TS_DISCONT) {
3706             if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3707                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3708                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3709                 pkt_dts+1<ist->pts){
3710                 input_files[ist->file_index]->ts_offset -= delta;
3711                 av_log(NULL, AV_LOG_DEBUG,
3712                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3713                        delta, input_files[ist->file_index]->ts_offset);
3714                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3715                 if (pkt.pts != AV_NOPTS_VALUE)
3716                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3717             }
3718             } else {
3719                 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3720                     (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3721                      pkt_dts+1<ist->pts){
3722                     av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3723                     pkt.dts = AV_NOPTS_VALUE;
3724                 }
3725                 if (pkt.pts != AV_NOPTS_VALUE){
3726                     int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3727                     delta   = pkt_pts - ist->next_dts;
3728                     if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3729                         (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3730                         pkt_pts+1<ist->pts) {
3731                         av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3732                         pkt.pts = AV_NOPTS_VALUE;
3733                     }
3734                 }
3735             }
3736         }
3737
3738         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3739         if ((ret = output_packet(ist, &pkt)) < 0 ||
3740             ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3741             char buf[128];
3742             av_strerror(ret, buf, sizeof(buf));
3743             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
3744                    ist->file_index, ist->st->index, buf);
3745             if (exit_on_error)
3746                 exit_program(1);
3747             av_free_packet(&pkt);
3748             continue;
3749         }
3750
3751     discard_packet:
3752         av_free_packet(&pkt);
3753
3754         /* dump report by using the output first video and audio streams */
3755         print_report(0, timer_start, cur_time);
3756     }
3757 #if HAVE_PTHREADS
3758     free_input_threads();
3759 #endif
3760
3761     /* at the end of stream, we must flush the decoder buffers */
3762     for (i = 0; i < nb_input_streams; i++) {
3763         ist = input_streams[i];
3764         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3765             output_packet(ist, NULL);
3766         }
3767     }
3768     poll_filters();
3769     flush_encoders();
3770
3771     term_exit();
3772
3773     /* write the trailer if needed and close file */
3774     for (i = 0; i < nb_output_files; i++) {
3775         os = output_files[i]->ctx;
3776         av_write_trailer(os);
3777     }
3778
3779     /* dump report by using the first video and audio streams */
3780     print_report(1, timer_start, av_gettime());
3781
3782     /* close each encoder */
3783     for (i = 0; i < nb_output_streams; i++) {
3784         ost = output_streams[i];
3785         if (ost->encoding_needed) {
3786             av_freep(&ost->st->codec->stats_in);
3787             avcodec_close(ost->st->codec);
3788         }
3789     }
3790
3791     /* close each decoder */
3792     for (i = 0; i < nb_input_streams; i++) {
3793         ist = input_streams[i];
3794         if (ist->decoding_needed) {
3795             avcodec_close(ist->st->codec);
3796         }
3797     }
3798
3799     /* finished ! */
3800     ret = 0;
3801
3802  fail:
3803     av_freep(&no_packet);
3804 #if HAVE_PTHREADS
3805     free_input_threads();
3806 #endif
3807
3808     if (output_streams) {
3809         for (i = 0; i < nb_output_streams; i++) {
3810             ost = output_streams[i];
3811             if (ost) {
3812                 if (ost->stream_copy)
3813                     av_freep(&ost->st->codec->extradata);
3814                 if (ost->logfile) {
3815                     fclose(ost->logfile);
3816                     ost->logfile = NULL;
3817                 }
3818                 av_freep(&ost->st->codec->subtitle_header);
3819                 av_free(ost->forced_kf_pts);
3820                 av_dict_free(&ost->opts);
3821             }
3822         }
3823     }
3824     return ret;
3825 }
3826
3827 static int opt_frame_crop(const char *opt, const char *arg)
3828 {
3829     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3830     return AVERROR(EINVAL);
3831 }
3832
3833 static int opt_pad(const char *opt, const char *arg)
3834 {
3835     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3836     return -1;
3837 }
3838
3839 static int opt_video_channel(const char *opt, const char *arg)
3840 {
3841     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3842     return opt_default("channel", arg);
3843 }
3844
3845 static int opt_video_standard(const char *opt, const char *arg)
3846 {
3847     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3848     return opt_default("standard", arg);
3849 }
3850
3851 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3852 {
3853     audio_codec_name = arg;
3854     return parse_option(o, "codec:a", arg, options);
3855 }
3856
3857 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3858 {
3859     video_codec_name = arg;
3860     return parse_option(o, "codec:v", arg, options);
3861 }
3862
3863 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3864 {
3865     subtitle_codec_name = arg;
3866     return parse_option(o, "codec:s", arg, options);
3867 }
3868
3869 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3870 {
3871     return parse_option(o, "codec:d", arg, options);
3872 }
3873
3874 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3875 {
3876     StreamMap *m = NULL;
3877     int i, negative = 0, file_idx;
3878     int sync_file_idx = -1, sync_stream_idx = 0;
3879     char *p, *sync;
3880     char *map;
3881
3882     if (*arg == '-') {
3883         negative = 1;
3884         arg++;
3885     }
3886     map = av_strdup(arg);
3887
3888     /* parse sync stream first, just pick first matching stream */
3889     if (sync = strchr(map, ',')) {
3890         *sync = 0;
3891         sync_file_idx = strtol(sync + 1, &sync, 0);
3892         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3893             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3894             exit_program(1);
3895         }
3896         if (*sync)
3897             sync++;
3898         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3899             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3900                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3901                 sync_stream_idx = i;
3902                 break;
3903             }
3904         if (i == input_files[sync_file_idx]->nb_streams) {
3905             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3906                                        "match any streams.\n", arg);
3907             exit_program(1);
3908         }
3909     }
3910
3911
3912     if (map[0] == '[') {
3913         /* this mapping refers to lavfi output */
3914         const char *c = map + 1;
3915         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3916                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
3917         m = &o->stream_maps[o->nb_stream_maps - 1];
3918         m->linklabel = av_get_token(&c, "]");
3919         if (!m->linklabel) {
3920             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3921             exit_program(1);
3922         }
3923     } else {
3924         file_idx = strtol(map, &p, 0);
3925         if (file_idx >= nb_input_files || file_idx < 0) {
3926             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3927             exit_program(1);
3928         }
3929         if (negative)
3930             /* disable some already defined maps */
3931             for (i = 0; i < o->nb_stream_maps; i++) {
3932                 m = &o->stream_maps[i];
3933                 if (file_idx == m->file_index &&
3934                     check_stream_specifier(input_files[m->file_index]->ctx,
3935                                            input_files[m->file_index]->ctx->streams[m->stream_index],
3936                                            *p == ':' ? p + 1 : p) > 0)
3937                     m->disabled = 1;
3938             }
3939         else
3940             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3941                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3942                             *p == ':' ? p + 1 : p) <= 0)
3943                     continue;
3944                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3945                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
3946                 m = &o->stream_maps[o->nb_stream_maps - 1];
3947
3948                 m->file_index   = file_idx;
3949                 m->stream_index = i;
3950
3951                 if (sync_file_idx >= 0) {
3952                     m->sync_file_index   = sync_file_idx;
3953                     m->sync_stream_index = sync_stream_idx;
3954                 } else {
3955                     m->sync_file_index   = file_idx;
3956                     m->sync_stream_index = i;
3957                 }
3958             }
3959     }
3960
3961     if (!m) {
3962         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3963         exit_program(1);
3964     }
3965
3966     av_freep(&map);
3967     return 0;
3968 }
3969
3970 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3971 {
3972     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3973                                 &o->nb_attachments, o->nb_attachments + 1);
3974     o->attachments[o->nb_attachments - 1] = arg;
3975     return 0;
3976 }
3977
3978 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3979 {
3980     int n;
3981     AVStream *st;
3982     AudioChannelMap *m;
3983
3984     o->audio_channel_maps =
3985         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3986                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3987     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3988
3989     /* muted channel syntax */
3990     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3991     if ((n == 1 || n == 3) && m->channel_idx == -1) {
3992         m->file_idx = m->stream_idx = -1;
3993         if (n == 1)
3994             m->ofile_idx = m->ostream_idx = -1;
3995         return 0;
3996     }
3997
3998     /* normal syntax */
3999     n = sscanf(arg, "%d.%d.%d:%d.%d",
4000                &m->file_idx,  &m->stream_idx, &m->channel_idx,
4001                &m->ofile_idx, &m->ostream_idx);
4002
4003     if (n != 3 && n != 5) {
4004         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
4005                "[file.stream.channel|-1][:syncfile:syncstream]\n");
4006         exit_program(1);
4007     }
4008
4009     if (n != 5) // only file.stream.channel specified
4010         m->ofile_idx = m->ostream_idx = -1;
4011
4012     /* check input */
4013     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
4014         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
4015                m->file_idx);
4016         exit_program(1);
4017     }
4018     if (m->stream_idx < 0 ||
4019         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
4020         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
4021                m->file_idx, m->stream_idx);
4022         exit_program(1);
4023     }
4024     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
4025     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
4026         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
4027                m->file_idx, m->stream_idx);
4028         exit_program(1);
4029     }
4030     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
4031         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
4032                m->file_idx, m->stream_idx, m->channel_idx);
4033         exit_program(1);
4034     }
4035     return 0;
4036 }
4037
4038 /**
4039  * Parse a metadata specifier in arg.
4040  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
4041  * @param index for type c/p, chapter/program index is written here
4042  * @param stream_spec for type s, the stream specifier is written here
4043  */
4044 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
4045 {
4046     if (*arg) {
4047         *type = *arg;
4048         switch (*arg) {
4049         case 'g':
4050             break;
4051         case 's':
4052             if (*(++arg) && *arg != ':') {
4053                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
4054                 exit_program(1);
4055             }
4056             *stream_spec = *arg == ':' ? arg + 1 : "";
4057             break;
4058         case 'c':
4059         case 'p':
4060             if (*(++arg) == ':')
4061                 *index = strtol(++arg, NULL, 0);
4062             break;
4063         default:
4064             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
4065             exit_program(1);
4066         }
4067     } else
4068         *type = 'g';
4069 }
4070
4071 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
4072 {
4073     AVDictionary **meta_in = NULL;
4074     AVDictionary **meta_out = NULL;
4075     int i, ret = 0;
4076     char type_in, type_out;
4077     const char *istream_spec = NULL, *ostream_spec = NULL;
4078     int idx_in = 0, idx_out = 0;
4079
4080     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
4081     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
4082
4083     if (!ic) {
4084         if (type_out == 'g' || !*outspec)
4085             o->metadata_global_manual = 1;
4086         if (type_out == 's' || !*outspec)
4087             o->metadata_streams_manual = 1;
4088         if (type_out == 'c' || !*outspec)
4089             o->metadata_chapters_manual = 1;
4090         return 0;
4091     }
4092
4093     if (type_in == 'g' || type_out == 'g')
4094         o->metadata_global_manual = 1;
4095     if (type_in == 's' || type_out == 's')
4096         o->metadata_streams_manual = 1;
4097     if (type_in == 'c' || type_out == 'c')
4098         o->metadata_chapters_manual = 1;
4099
4100 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4101     if ((index) < 0 || (index) >= (nb_elems)) {\
4102         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4103                 (desc), (index));\
4104         exit_program(1);\
4105     }
4106
4107 #define SET_DICT(type, meta, context, index)\
4108         switch (type) {\
4109         case 'g':\
4110             meta = &context->metadata;\
4111             break;\
4112         case 'c':\
4113             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4114             meta = &context->chapters[index]->metadata;\
4115             break;\
4116         case 'p':\
4117             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4118             meta = &context->programs[index]->metadata;\
4119             break;\
4120         default: av_assert0(0);\
4121         }\
4122
4123     SET_DICT(type_in, meta_in, ic, idx_in);
4124     SET_DICT(type_out, meta_out, oc, idx_out);
4125
4126     /* for input streams choose first matching stream */
4127     if (type_in == 's') {
4128         for (i = 0; i < ic->nb_streams; i++) {
4129             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4130                 meta_in = &ic->streams[i]->metadata;
4131                 break;
4132             } else if (ret < 0)
4133                 exit_program(1);
4134         }
4135         if (!meta_in) {
4136             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
4137             exit_program(1);
4138         }
4139     }
4140
4141     if (type_out == 's') {
4142         for (i = 0; i < oc->nb_streams; i++) {
4143             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4144                 meta_out = &oc->streams[i]->metadata;
4145                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4146             } else if (ret < 0)
4147                 exit_program(1);
4148         }
4149     } else
4150         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4151
4152     return 0;
4153 }
4154
4155 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4156 {
4157     char buf[128];
4158     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4159     struct tm time = *gmtime((time_t*)&recording_timestamp);
4160     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4161     parse_option(o, "metadata", buf, options);
4162
4163     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4164                                  "tag instead.\n", opt);
4165     return 0;
4166 }
4167
4168 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4169 {
4170     const char *codec_string = encoder ? "encoder" : "decoder";
4171     AVCodec *codec;
4172
4173     codec = encoder ?
4174         avcodec_find_encoder_by_name(name) :
4175         avcodec_find_decoder_by_name(name);
4176     if (!codec) {
4177         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4178         exit_program(1);
4179     }
4180     if (codec->type != type) {
4181         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4182         exit_program(1);
4183     }
4184     return codec;
4185 }
4186
4187 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4188 {
4189     char *codec_name = NULL;
4190
4191     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4192     if (codec_name) {
4193         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4194         st->codec->codec_id = codec->id;
4195         return codec;
4196     } else
4197         return avcodec_find_decoder(st->codec->codec_id);
4198 }
4199
4200 /**
4201  * Add all the streams from the given input file to the global
4202  * list of input streams.
4203  */
4204 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4205 {
4206     int i;
4207     char *next, *codec_tag = NULL;
4208
4209     for (i = 0; i < ic->nb_streams; i++) {
4210         AVStream *st = ic->streams[i];
4211         AVCodecContext *dec = st->codec;
4212         InputStream *ist = av_mallocz(sizeof(*ist));
4213         char *framerate = NULL;
4214
4215         if (!ist)
4216             exit_program(1);
4217
4218         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4219         input_streams[nb_input_streams - 1] = ist;
4220
4221         ist->st = st;
4222         ist->file_index = nb_input_files;
4223         ist->discard = 1;
4224         st->discard  = AVDISCARD_ALL;
4225         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
4226
4227         ist->ts_scale = 1.0;
4228         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4229
4230         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4231         if (codec_tag) {
4232             uint32_t tag = strtol(codec_tag, &next, 0);
4233             if (*next)
4234                 tag = AV_RL32(codec_tag);
4235             st->codec->codec_tag = tag;
4236         }
4237
4238         ist->dec = choose_decoder(o, ic, st);
4239
4240         switch (dec->codec_type) {
4241         case AVMEDIA_TYPE_VIDEO:
4242             if(!ist->dec)
4243                 ist->dec = avcodec_find_decoder(dec->codec_id);
4244             if (dec->lowres) {
4245                 dec->flags |= CODEC_FLAG_EMU_EDGE;
4246             }
4247
4248             ist->resample_height  = dec->height;
4249             ist->resample_width   = dec->width;
4250             ist->resample_pix_fmt = dec->pix_fmt;
4251
4252             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
4253             if (framerate && av_parse_video_rate(&ist->framerate,
4254                                                  framerate) < 0) {
4255                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
4256                        framerate);
4257                 exit_program(1);
4258             }
4259
4260             ist->top_field_first = -1;
4261             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
4262
4263             break;
4264         case AVMEDIA_TYPE_AUDIO:
4265             guess_input_channel_layout(ist);
4266
4267             ist->resample_sample_fmt     = dec->sample_fmt;
4268             ist->resample_sample_rate    = dec->sample_rate;
4269             ist->resample_channels       = dec->channels;
4270             ist->resample_channel_layout = dec->channel_layout;
4271
4272             break;
4273         case AVMEDIA_TYPE_DATA:
4274         case AVMEDIA_TYPE_SUBTITLE:
4275             if(!ist->dec)
4276                 ist->dec = avcodec_find_decoder(dec->codec_id);
4277             break;
4278         case AVMEDIA_TYPE_ATTACHMENT:
4279         case AVMEDIA_TYPE_UNKNOWN:
4280             break;
4281         default:
4282             abort();
4283         }
4284     }
4285 }
4286
4287 static void assert_file_overwrite(const char *filename)
4288 {
4289     if ((!file_overwrite || no_file_overwrite) &&
4290         (strchr(filename, ':') == NULL || filename[1] == ':' ||
4291          av_strstart(filename, "file:", NULL))) {
4292         if (avio_check(filename, 0) == 0) {
4293             if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
4294                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4295                 fflush(stderr);
4296                 term_exit();
4297                 signal(SIGINT, SIG_DFL);
4298                 if (!read_yesno()) {
4299                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4300                     exit_program(1);
4301                 }
4302                 term_init();
4303             }
4304             else {
4305                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4306                 exit_program(1);
4307             }
4308         }
4309     }
4310 }
4311
4312 static void dump_attachment(AVStream *st, const char *filename)
4313 {
4314     int ret;
4315     AVIOContext *out = NULL;
4316     AVDictionaryEntry *e;
4317
4318     if (!st->codec->extradata_size) {
4319         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4320                nb_input_files - 1, st->index);
4321         return;
4322     }
4323     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4324         filename = e->value;
4325     if (!*filename) {
4326         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4327                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4328         exit_program(1);
4329     }
4330
4331     assert_file_overwrite(filename);
4332
4333     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4334         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4335                filename);
4336         exit_program(1);
4337     }
4338
4339     avio_write(out, st->codec->extradata, st->codec->extradata_size);
4340     avio_flush(out);
4341     avio_close(out);
4342 }
4343
4344 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4345 {
4346     AVFormatContext *ic;
4347     AVInputFormat *file_iformat = NULL;
4348     int err, i, ret;
4349     int64_t timestamp;
4350     uint8_t buf[128];
4351     AVDictionary **opts;
4352     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
4353
4354     if (o->format) {
4355         if (!(file_iformat = av_find_input_format(o->format))) {
4356             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4357             exit_program(1);
4358         }
4359     }
4360
4361     if (!strcmp(filename, "-"))
4362         filename = "pipe:";
4363
4364     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
4365                          strcmp(filename, "/dev/stdin");
4366
4367     /* get default parameters from command line */
4368     ic = avformat_alloc_context();
4369     if (!ic) {
4370         print_error(filename, AVERROR(ENOMEM));
4371         exit_program(1);
4372     }
4373     if (o->nb_audio_sample_rate) {
4374         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4375         av_dict_set(&format_opts, "sample_rate", buf, 0);
4376     }
4377     if (o->nb_audio_channels) {
4378         /* because we set audio_channels based on both the "ac" and
4379          * "channel_layout" options, we need to check that the specified
4380          * demuxer actually has the "channels" option before setting it */
4381         if (file_iformat && file_iformat->priv_class &&
4382             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4383                         AV_OPT_SEARCH_FAKE_OBJ)) {
4384             snprintf(buf, sizeof(buf), "%d",
4385                      o->audio_channels[o->nb_audio_channels - 1].u.i);
4386             av_dict_set(&format_opts, "channels", buf, 0);
4387         }
4388     }
4389     if (o->nb_frame_rates) {
4390         /* set the format-level framerate option;
4391          * this is important for video grabbers, e.g. x11 */
4392         if (file_iformat && file_iformat->priv_class &&
4393             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
4394                         AV_OPT_SEARCH_FAKE_OBJ)) {
4395             av_dict_set(&format_opts, "framerate",
4396                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4397         }
4398     }
4399     if (o->nb_frame_sizes) {
4400         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4401     }
4402     if (o->nb_frame_pix_fmts)
4403         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4404
4405     ic->video_codec_id   = video_codec_name ?
4406         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
4407     ic->audio_codec_id   = audio_codec_name ?
4408         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
4409     ic->subtitle_codec_id= subtitle_codec_name ?
4410         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4411     ic->flags |= AVFMT_FLAG_NONBLOCK;
4412     ic->interrupt_callback = int_cb;
4413
4414     /* open the input file with generic avformat function */
4415     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4416     if (err < 0) {
4417         print_error(filename, err);
4418         exit_program(1);
4419     }
4420     assert_avoptions(format_opts);
4421
4422     /* apply forced codec ids */
4423     for (i = 0; i < ic->nb_streams; i++)
4424         choose_decoder(o, ic, ic->streams[i]);
4425
4426     /* Set AVCodecContext options for avformat_find_stream_info */
4427     opts = setup_find_stream_info_opts(ic, codec_opts);
4428     orig_nb_streams = ic->nb_streams;
4429
4430     /* If not enough info to get the stream parameters, we decode the
4431        first frames to get it. (used in mpeg case for example) */
4432     ret = avformat_find_stream_info(ic, opts);
4433     if (ret < 0) {
4434         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4435         avformat_close_input(&ic);
4436         exit_program(1);
4437     }
4438
4439     timestamp = o->start_time;
4440     /* add the stream start time */
4441     if (ic->start_time != AV_NOPTS_VALUE)
4442         timestamp += ic->start_time;
4443
4444     /* if seeking requested, we execute it */
4445     if (o->start_time != 0) {
4446         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4447         if (ret < 0) {
4448             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4449                    filename, (double)timestamp / AV_TIME_BASE);
4450         }
4451     }
4452
4453     /* update the current parameters so that they match the one of the input stream */
4454     add_input_streams(o, ic);
4455
4456     /* dump the file content */
4457     av_dump_format(ic, nb_input_files, filename, 0);
4458
4459     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4460     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4461         exit_program(1);
4462
4463     input_files[nb_input_files - 1]->ctx        = ic;
4464     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
4465     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4466     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4467     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
4468
4469     for (i = 0; i < o->nb_dump_attachment; i++) {
4470         int j;
4471
4472         for (j = 0; j < ic->nb_streams; j++) {
4473             AVStream *st = ic->streams[j];
4474
4475             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4476                 dump_attachment(st, o->dump_attachment[i].u.str);
4477         }
4478     }
4479
4480     for (i = 0; i < orig_nb_streams; i++)
4481         av_dict_free(&opts[i]);
4482     av_freep(&opts);
4483
4484     reset_options(o, 1);
4485     return 0;
4486 }
4487
4488 static uint8_t *get_line(AVIOContext *s)
4489 {
4490     AVIOContext *line;
4491     uint8_t *buf;
4492     char c;
4493
4494     if (avio_open_dyn_buf(&line) < 0) {
4495         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4496         exit_program(1);
4497     }
4498
4499     while ((c = avio_r8(s)) && c != '\n')
4500         avio_w8(line, c);
4501     avio_w8(line, 0);
4502     avio_close_dyn_buf(line, &buf);
4503
4504     return buf;
4505 }
4506
4507 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4508 {
4509     int i, ret = 1;
4510     char filename[1000];
4511     const char *base[3] = { getenv("AVCONV_DATADIR"),
4512                             getenv("HOME"),
4513                             AVCONV_DATADIR,
4514                             };
4515
4516     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4517         if (!base[i])
4518             continue;
4519         if (codec_name) {
4520             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4521                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
4522             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4523         }
4524         if (ret) {
4525             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4526                      i != 1 ? "" : "/.avconv", preset_name);
4527             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4528         }
4529     }
4530     return ret;
4531 }
4532
4533 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4534 {
4535     char *codec_name = NULL;
4536
4537     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4538     if (!codec_name) {
4539         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4540                                                   NULL, ost->st->codec->codec_type);
4541         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4542     } else if (!strcmp(codec_name, "copy"))
4543         ost->stream_copy = 1;
4544     else {
4545         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4546         ost->st->codec->codec_id = ost->enc->id;
4547     }
4548 }
4549
4550 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4551 {
4552     OutputStream *ost;
4553     AVStream *st = avformat_new_stream(oc, NULL);
4554     int idx      = oc->nb_streams - 1, ret = 0;
4555     char *bsf = NULL, *next, *codec_tag = NULL;
4556     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4557     double qscale = -1;
4558     char *buf = NULL, *arg = NULL, *preset = NULL;
4559     AVIOContext *s = NULL;
4560
4561     if (!st) {
4562         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4563         exit_program(1);
4564     }
4565
4566     if (oc->nb_streams - 1 < o->nb_streamid_map)
4567         st->id = o->streamid_map[oc->nb_streams - 1];
4568
4569     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4570                                 nb_output_streams + 1);
4571     if (!(ost = av_mallocz(sizeof(*ost))))
4572         exit_program(1);
4573     output_streams[nb_output_streams - 1] = ost;
4574
4575     ost->file_index = nb_output_files;
4576     ost->index      = idx;
4577     ost->st         = st;
4578     st->codec->codec_type = type;
4579     choose_encoder(o, oc, ost);
4580     if (ost->enc) {
4581         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
4582     }
4583
4584     avcodec_get_context_defaults3(st->codec, ost->enc);
4585     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4586
4587     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4588     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4589         do  {
4590             buf = get_line(s);
4591             if (!buf[0] || buf[0] == '#') {
4592                 av_free(buf);
4593                 continue;
4594             }
4595             if (!(arg = strchr(buf, '='))) {
4596                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4597                 exit_program(1);
4598             }
4599             *arg++ = 0;
4600             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4601             av_free(buf);
4602         } while (!s->eof_reached);
4603         avio_close(s);
4604     }
4605     if (ret) {
4606         av_log(NULL, AV_LOG_FATAL,
4607                "Preset %s specified for stream %d:%d, but could not be opened.\n",
4608                preset, ost->file_index, ost->index);
4609         exit_program(1);
4610     }
4611
4612     ost->max_frames = INT64_MAX;
4613     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4614
4615     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4616     while (bsf) {
4617         if (next = strchr(bsf, ','))
4618             *next++ = 0;
4619         if (!(bsfc = av_bitstream_filter_init(bsf))) {
4620             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4621             exit_program(1);
4622         }
4623         if (bsfc_prev)
4624             bsfc_prev->next = bsfc;
4625         else
4626             ost->bitstream_filters = bsfc;
4627
4628         bsfc_prev = bsfc;
4629         bsf       = next;
4630     }
4631
4632     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4633     if (codec_tag) {
4634         uint32_t tag = strtol(codec_tag, &next, 0);
4635         if (*next)
4636             tag = AV_RL32(codec_tag);
4637         st->codec->codec_tag = tag;
4638     }
4639
4640     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4641     if (qscale >= 0 || same_quant) {
4642         st->codec->flags |= CODEC_FLAG_QSCALE;
4643         st->codec->global_quality = FF_QP2LAMBDA * qscale;
4644     }
4645
4646     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4647         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4648
4649     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4650     av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4651     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4652
4653     ost->source_index = source_index;
4654     if (source_index >= 0) {
4655         ost->sync_ist = input_streams[source_index];
4656         input_streams[source_index]->discard = 0;
4657         input_streams[source_index]->st->discard = AVDISCARD_NONE;
4658     }
4659
4660     return ost;
4661 }
4662
4663 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4664 {
4665     int i;
4666     const char *p = str;
4667     for (i = 0;; i++) {
4668         dest[i] = atoi(p);
4669         if (i == 63)
4670             break;
4671         p = strchr(p, ',');
4672         if (!p) {
4673             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4674             exit_program(1);
4675         }
4676         p++;
4677     }
4678 }
4679
4680 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4681 {
4682     AVStream *st;
4683     OutputStream *ost;
4684     AVCodecContext *video_enc;
4685     char *frame_rate = NULL;
4686
4687     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4688     st  = ost->st;
4689     video_enc = st->codec;
4690
4691     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4692     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4693         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4694         exit_program(1);
4695     }
4696
4697     if (!ost->stream_copy) {
4698         const char *p = NULL;
4699         char *frame_size = NULL;
4700         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4701         char *intra_matrix = NULL, *inter_matrix = NULL;
4702         const char *filters = "null";
4703         int i;
4704
4705         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4706         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4707             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4708             exit_program(1);
4709         }
4710
4711         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4712         if (frame_aspect_ratio) {
4713             AVRational q;
4714             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4715                 q.num <= 0 || q.den <= 0) {
4716                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4717                 exit_program(1);
4718             }
4719             ost->frame_aspect_ratio = av_q2d(q);
4720         }
4721
4722         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4723         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4724         if (frame_pix_fmt && *frame_pix_fmt == '+') {
4725             ost->keep_pix_fmt = 1;
4726             if (!*++frame_pix_fmt)
4727                 frame_pix_fmt = NULL;
4728         }
4729         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4730             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4731             exit_program(1);
4732         }
4733         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4734
4735         if (intra_only)
4736             video_enc->gop_size = 0;
4737         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4738         if (intra_matrix) {
4739             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4740                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4741                 exit_program(1);
4742             }
4743             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4744         }
4745         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4746         if (inter_matrix) {
4747             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4748                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4749                 exit_program(1);
4750             }
4751             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4752         }
4753
4754         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4755         for (i = 0; p; i++) {
4756             int start, end, q;
4757             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4758             if (e != 3) {
4759                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4760                 exit_program(1);
4761             }
4762             /* FIXME realloc failure */
4763             video_enc->rc_override =
4764                 av_realloc(video_enc->rc_override,
4765                            sizeof(RcOverride) * (i + 1));
4766             video_enc->rc_override[i].start_frame = start;
4767             video_enc->rc_override[i].end_frame   = end;
4768             if (q > 0) {
4769                 video_enc->rc_override[i].qscale         = q;
4770                 video_enc->rc_override[i].quality_factor = 1.0;
4771             }
4772             else {
4773                 video_enc->rc_override[i].qscale         = 0;
4774                 video_enc->rc_override[i].quality_factor = -q/100.0;
4775             }
4776             p = strchr(p, '/');
4777             if (p) p++;
4778         }
4779         video_enc->rc_override_count = i;
4780         if (!video_enc->rc_initial_buffer_occupancy)
4781             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4782         video_enc->intra_dc_precision = intra_dc_precision - 8;
4783
4784         if (do_psnr)
4785             video_enc->flags|= CODEC_FLAG_PSNR;
4786
4787         /* two pass mode */
4788         if (do_pass) {
4789             if (do_pass & 1) {
4790                 video_enc->flags |= CODEC_FLAG_PASS1;
4791             }
4792             if (do_pass & 2) {
4793                 video_enc->flags |= CODEC_FLAG_PASS2;
4794             }
4795         }
4796
4797         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
4798         if (ost->forced_keyframes)
4799             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
4800
4801         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4802
4803         ost->top_field_first = -1;
4804         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4805
4806         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4807         ost->avfilter = av_strdup(filters);
4808     } else {
4809         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4810     }
4811
4812     return ost;
4813 }
4814
4815 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4816 {
4817     int n;
4818     AVStream *st;
4819     OutputStream *ost;
4820     AVCodecContext *audio_enc;
4821
4822     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4823     st  = ost->st;
4824
4825     audio_enc = st->codec;
4826     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4827
4828     if (!ost->stream_copy) {
4829         char *sample_fmt = NULL;
4830         const char *filters = "anull";
4831
4832         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4833
4834         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4835         if (sample_fmt &&
4836             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4837             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4838             exit_program(1);
4839         }
4840
4841         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4842
4843         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4844
4845         av_assert1(filters);
4846         ost->avfilter = av_strdup(filters);
4847
4848         /* check for channel mapping for this audio stream */
4849         for (n = 0; n < o->nb_audio_channel_maps; n++) {
4850             AudioChannelMap *map = &o->audio_channel_maps[n];
4851             InputStream *ist = input_streams[ost->source_index];
4852             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4853                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
4854                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
4855                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4856                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4857                 else
4858                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4859                            ost->file_index, ost->st->index);
4860             }
4861         }
4862     }
4863
4864     return ost;
4865 }
4866
4867 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4868 {
4869     OutputStream *ost;
4870
4871     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4872     if (!ost->stream_copy) {
4873         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4874         exit_program(1);
4875     }
4876
4877     return ost;
4878 }
4879
4880 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4881 {
4882     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4883     ost->stream_copy = 1;
4884     return ost;
4885 }
4886
4887 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4888 {
4889     AVStream *st;
4890     OutputStream *ost;
4891     AVCodecContext *subtitle_enc;
4892
4893     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4894     st  = ost->st;
4895     subtitle_enc = st->codec;
4896
4897     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4898
4899     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4900
4901     return ost;
4902 }
4903
4904 /* arg format is "output-stream-index:streamid-value". */
4905 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4906 {
4907     int idx;
4908     char *p;
4909     char idx_str[16];
4910
4911     av_strlcpy(idx_str, arg, sizeof(idx_str));
4912     p = strchr(idx_str, ':');
4913     if (!p) {
4914         av_log(NULL, AV_LOG_FATAL,
4915                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4916                arg, opt);
4917         exit_program(1);
4918     }
4919     *p++ = '\0';
4920     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4921     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4922     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4923     return 0;
4924 }
4925
4926 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4927 {
4928     AVFormatContext *is = ifile->ctx;
4929     AVFormatContext *os = ofile->ctx;
4930     int i;
4931
4932     for (i = 0; i < is->nb_chapters; i++) {
4933         AVChapter *in_ch = is->chapters[i], *out_ch;
4934         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
4935                                        AV_TIME_BASE_Q, in_ch->time_base);
4936         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4937                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4938
4939
4940         if (in_ch->end < ts_off)
4941             continue;
4942         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4943             break;
4944
4945         out_ch = av_mallocz(sizeof(AVChapter));
4946         if (!out_ch)
4947             return AVERROR(ENOMEM);
4948
4949         out_ch->id        = in_ch->id;
4950         out_ch->time_base = in_ch->time_base;
4951         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
4952         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
4953
4954         if (copy_metadata)
4955             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4956
4957         os->nb_chapters++;
4958         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4959         if (!os->chapters)
4960             return AVERROR(ENOMEM);
4961         os->chapters[os->nb_chapters - 1] = out_ch;
4962     }
4963     return 0;
4964 }
4965
4966 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4967 {
4968     int i, err;
4969     AVFormatContext *ic = avformat_alloc_context();
4970
4971     ic->interrupt_callback = int_cb;
4972     err = avformat_open_input(&ic, filename, NULL, NULL);
4973     if (err < 0)
4974         return err;
4975     /* copy stream format */
4976     for(i=0;i<ic->nb_streams;i++) {
4977         AVStream *st;
4978         OutputStream *ost;
4979         AVCodec *codec;
4980         AVCodecContext *avctx;
4981
4982         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4983         ost   = new_output_stream(o, s, codec->type, -1);
4984         st    = ost->st;
4985         avctx = st->codec;
4986         ost->enc = codec;
4987
4988         // FIXME: a more elegant solution is needed
4989         memcpy(st, ic->streams[i], sizeof(AVStream));
4990         st->cur_dts = 0;
4991         st->info = av_malloc(sizeof(*st->info));
4992         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4993         st->codec= avctx;
4994         avcodec_copy_context(st->codec, ic->streams[i]->codec);
4995
4996         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4997             choose_sample_fmt(st, codec);
4998         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4999             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
5000     }
5001
5002     avformat_close_input(&ic);
5003     return 0;
5004 }
5005
5006 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
5007                                AVFormatContext *oc)
5008 {
5009     OutputStream *ost;
5010
5011     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
5012                                   ofilter->out_tmp->pad_idx)) {
5013     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
5014     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
5015     default:
5016         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
5017                "currently.\n");
5018         exit_program(1);
5019     }
5020
5021     ost->source_index = -1;
5022     ost->filter       = ofilter;
5023
5024     ofilter->ost      = ost;
5025
5026     if (ost->stream_copy) {
5027         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
5028                "which is fed from a complex filtergraph. Filtering and streamcopy "
5029                "cannot be used together.\n", ost->file_index, ost->index);
5030         exit_program(1);
5031     }
5032     if (o->recording_time != INT64_MAX)
5033         av_log(NULL, AV_LOG_WARNING,
5034                "-t does not work with -filter_complex (yet).\n");
5035
5036     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
5037         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
5038         exit_program(1);
5039     }
5040     avfilter_inout_free(&ofilter->out_tmp);
5041 }
5042
5043 static void opt_output_file(void *optctx, const char *filename)
5044 {
5045     OptionsContext *o = optctx;
5046     AVFormatContext *oc;
5047     int i, j, err;
5048     AVOutputFormat *file_oformat;
5049     OutputStream *ost;
5050     InputStream  *ist;
5051
5052     if (configure_complex_filters() < 0) {
5053         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
5054         exit_program(1);
5055     }
5056
5057     if (!strcmp(filename, "-"))
5058         filename = "pipe:";
5059
5060     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
5061     if (!oc) {
5062         print_error(filename, err);
5063         exit_program(1);
5064     }
5065     file_oformat= oc->oformat;
5066     oc->interrupt_callback = int_cb;
5067
5068     /* create streams for all unlabeled output pads */
5069     for (i = 0; i < nb_filtergraphs; i++) {
5070         FilterGraph *fg = filtergraphs[i];
5071         for (j = 0; j < fg->nb_outputs; j++) {
5072             OutputFilter *ofilter = fg->outputs[j];
5073
5074             if (!ofilter->out_tmp || ofilter->out_tmp->name)
5075                 continue;
5076
5077             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
5078                                           ofilter->out_tmp->pad_idx)) {
5079             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
5080             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
5081             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
5082             }
5083             init_output_filter(ofilter, o, oc);
5084         }
5085     }
5086
5087     if (!strcmp(file_oformat->name, "ffm") &&
5088         av_strstart(filename, "http:", NULL)) {
5089         int j;
5090         /* special case for files sent to ffserver: we get the stream
5091            parameters from ffserver */
5092         int err = read_ffserver_streams(o, oc, filename);
5093         if (err < 0) {
5094             print_error(filename, err);
5095             exit_program(1);
5096         }
5097         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
5098             ost = output_streams[j];
5099             for (i = 0; i < nb_input_streams; i++) {
5100                 ist = input_streams[i];
5101                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
5102                     ost->sync_ist= ist;
5103                     ost->source_index= i;
5104                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
5105                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
5106                     ist->discard = 0;
5107                     ist->st->discard = AVDISCARD_NONE;
5108                     break;
5109                 }
5110             }
5111             if(!ost->sync_ist){
5112                 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
5113                 exit_program(1);
5114             }
5115         }
5116     } else if (!o->nb_stream_maps) {
5117         /* pick the "best" stream of each type */
5118
5119         /* video: highest resolution */
5120         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5121             int area = 0, idx = -1;
5122             for (i = 0; i < nb_input_streams; i++) {
5123                 ist = input_streams[i];
5124                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5125                     ist->st->codec->width * ist->st->codec->height > area) {
5126                     area = ist->st->codec->width * ist->st->codec->height;
5127                     idx = i;
5128                 }
5129             }
5130             if (idx >= 0)
5131                 new_video_stream(o, oc, idx);
5132         }
5133
5134         /* audio: most channels */
5135         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5136             int channels = 0, idx = -1;
5137             for (i = 0; i < nb_input_streams; i++) {
5138                 ist = input_streams[i];
5139                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5140                     ist->st->codec->channels > channels) {
5141                     channels = ist->st->codec->channels;
5142                     idx = i;
5143                 }
5144             }
5145             if (idx >= 0)
5146                 new_audio_stream(o, oc, idx);
5147         }
5148
5149         /* subtitles: pick first */
5150         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5151             for (i = 0; i < nb_input_streams; i++)
5152                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5153                     new_subtitle_stream(o, oc, i);
5154                     break;
5155                 }
5156         }
5157         /* do something with data? */
5158     } else {
5159         for (i = 0; i < o->nb_stream_maps; i++) {
5160             StreamMap *map = &o->stream_maps[i];
5161             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5162
5163             if (map->disabled)
5164                 continue;
5165
5166             if (map->linklabel) {
5167                 FilterGraph *fg;
5168                 OutputFilter *ofilter = NULL;
5169                 int j, k;
5170
5171                 for (j = 0; j < nb_filtergraphs; j++) {
5172                     fg = filtergraphs[j];
5173                     for (k = 0; k < fg->nb_outputs; k++) {
5174                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
5175                         if (out && !strcmp(out->name, map->linklabel)) {
5176                             ofilter = fg->outputs[k];
5177                             goto loop_end;
5178                         }
5179                     }
5180                 }
5181 loop_end:
5182                 if (!ofilter) {
5183                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5184                            "in any defined filter graph.\n", map->linklabel);
5185                     exit_program(1);
5186                 }
5187                 init_output_filter(ofilter, o, oc);
5188             } else {
5189                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5190                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5191                     continue;
5192                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5193                     continue;
5194                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5195                     continue;
5196                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5197                     continue;
5198
5199                 switch (ist->st->codec->codec_type) {
5200                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
5201                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
5202                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
5203                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
5204                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5205                 default:
5206                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5207                            map->file_index, map->stream_index);
5208                     exit_program(1);
5209                 }
5210             }
5211         }
5212     }
5213
5214
5215     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5216         AVDictionaryEntry *e;
5217         ost = output_streams[i];
5218
5219         if (   ost->stream_copy
5220             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5221             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5222             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5223                 exit_program(1);
5224     }
5225
5226     /* handle attached files */
5227     for (i = 0; i < o->nb_attachments; i++) {
5228         AVIOContext *pb;
5229         uint8_t *attachment;
5230         const char *p;
5231         int64_t len;
5232
5233         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5234             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5235                    o->attachments[i]);
5236             exit_program(1);
5237         }
5238         if ((len = avio_size(pb)) <= 0) {
5239             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5240                    o->attachments[i]);
5241             exit_program(1);
5242         }
5243         if (!(attachment = av_malloc(len))) {
5244             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5245                    o->attachments[i]);
5246             exit_program(1);
5247         }
5248         avio_read(pb, attachment, len);
5249
5250         ost = new_attachment_stream(o, oc, -1);
5251         ost->stream_copy               = 0;
5252         ost->attachment_filename       = o->attachments[i];
5253         ost->st->codec->extradata      = attachment;
5254         ost->st->codec->extradata_size = len;
5255
5256         p = strrchr(o->attachments[i], '/');
5257         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5258         avio_close(pb);
5259     }
5260
5261     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5262     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5263         exit_program(1);
5264
5265     output_files[nb_output_files - 1]->ctx            = oc;
5266     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
5267     output_files[nb_output_files - 1]->recording_time = o->recording_time;
5268     if (o->recording_time != INT64_MAX)
5269         oc->duration = o->recording_time;
5270     output_files[nb_output_files - 1]->start_time     = o->start_time;
5271     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5272     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5273
5274     /* check filename in case of an image number is expected */
5275     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5276         if (!av_filename_number_test(oc->filename)) {
5277             print_error(oc->filename, AVERROR(EINVAL));
5278             exit_program(1);
5279         }
5280     }
5281
5282     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5283         /* test if it already exists to avoid losing precious files */
5284         assert_file_overwrite(filename);
5285
5286         /* open the file */
5287         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5288                               &oc->interrupt_callback,
5289                               &output_files[nb_output_files - 1]->opts)) < 0) {
5290             print_error(filename, err);
5291             exit_program(1);
5292         }
5293     }
5294
5295     if (o->mux_preload) {
5296         uint8_t buf[64];
5297         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5298         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5299     }
5300     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5301
5302     /* copy metadata */
5303     for (i = 0; i < o->nb_metadata_map; i++) {
5304         char *p;
5305         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5306
5307         if (in_file_index >= nb_input_files) {
5308             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5309             exit_program(1);
5310         }
5311         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5312     }
5313
5314     /* copy chapters */
5315     if (o->chapters_input_file >= nb_input_files) {
5316         if (o->chapters_input_file == INT_MAX) {
5317             /* copy chapters from the first input file that has them*/
5318             o->chapters_input_file = -1;
5319             for (i = 0; i < nb_input_files; i++)
5320                 if (input_files[i]->ctx->nb_chapters) {
5321                     o->chapters_input_file = i;
5322                     break;
5323                 }
5324         } else {
5325             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5326                    o->chapters_input_file);
5327             exit_program(1);
5328         }
5329     }
5330     if (o->chapters_input_file >= 0)
5331         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5332                       !o->metadata_chapters_manual);
5333
5334     /* copy global metadata by default */
5335     if (!o->metadata_global_manual && nb_input_files){
5336         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5337                      AV_DICT_DONT_OVERWRITE);
5338         if(o->recording_time != INT64_MAX)
5339             av_dict_set(&oc->metadata, "duration", NULL, 0);
5340         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
5341     }
5342     if (!o->metadata_streams_manual)
5343         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5344             InputStream *ist;
5345             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
5346                 continue;
5347             ist = input_streams[output_streams[i]->source_index];
5348             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5349         }
5350
5351     /* process manually set metadata */
5352     for (i = 0; i < o->nb_metadata; i++) {
5353         AVDictionary **m;
5354         char type, *val;
5355         const char *stream_spec;
5356         int index = 0, j, ret = 0;
5357
5358         val = strchr(o->metadata[i].u.str, '=');
5359         if (!val) {
5360             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5361                    o->metadata[i].u.str);
5362             exit_program(1);
5363         }
5364         *val++ = 0;
5365
5366         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5367         if (type == 's') {
5368             for (j = 0; j < oc->nb_streams; j++) {
5369                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5370                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5371                 } else if (ret < 0)
5372                     exit_program(1);
5373             }
5374         }
5375         else {
5376             switch (type) {
5377             case 'g':
5378                 m = &oc->metadata;
5379                 break;
5380             case 'c':
5381                 if (index < 0 || index >= oc->nb_chapters) {
5382                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5383                     exit_program(1);
5384                 }
5385                 m = &oc->chapters[index]->metadata;
5386                 break;
5387             default:
5388                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5389                 exit_program(1);
5390             }
5391             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5392         }
5393     }
5394
5395     reset_options(o, 0);
5396 }
5397
5398 /* same option as mencoder */
5399 static int opt_pass(const char *opt, const char *arg)
5400 {
5401     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5402     return 0;
5403 }
5404
5405 static int64_t getmaxrss(void)
5406 {
5407 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5408     struct rusage rusage;
5409     getrusage(RUSAGE_SELF, &rusage);
5410     return (int64_t)rusage.ru_maxrss * 1024;
5411 #elif HAVE_GETPROCESSMEMORYINFO
5412     HANDLE proc;
5413     PROCESS_MEMORY_COUNTERS memcounters;
5414     proc = GetCurrentProcess();
5415     memcounters.cb = sizeof(memcounters);
5416     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5417     return memcounters.PeakPagefileUsage;
5418 #else
5419     return 0;
5420 #endif
5421 }
5422
5423 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5424 {
5425     return parse_option(o, "q:a", arg, options);
5426 }
5427
5428 static void show_usage(void)
5429 {
5430     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5431     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5432     av_log(NULL, AV_LOG_INFO, "\n");
5433 }
5434
5435 static int opt_help(const char *opt, const char *arg)
5436 {
5437     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5438     av_log_set_callback(log_callback_help);
5439     show_usage();
5440     show_help_options(options, "Main options:\n",
5441                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5442     show_help_options(options, "\nAdvanced options:\n",
5443                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5444                       OPT_EXPERT);
5445     show_help_options(options, "\nVideo options:\n",
5446                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5447                       OPT_VIDEO);
5448     show_help_options(options, "\nAdvanced Video options:\n",
5449                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5450                       OPT_VIDEO | OPT_EXPERT);
5451     show_help_options(options, "\nAudio options:\n",
5452                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5453                       OPT_AUDIO);
5454     show_help_options(options, "\nAdvanced Audio options:\n",
5455                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5456                       OPT_AUDIO | OPT_EXPERT);
5457     show_help_options(options, "\nSubtitle options:\n",
5458                       OPT_SUBTITLE | OPT_GRAB,
5459                       OPT_SUBTITLE);
5460     show_help_options(options, "\nAudio/Video grab options:\n",
5461                       OPT_GRAB,
5462                       OPT_GRAB);
5463     printf("\n");
5464     show_help_children(avcodec_get_class(), flags);
5465     show_help_children(avformat_get_class(), flags);
5466     show_help_children(sws_get_class(), flags);
5467     show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
5468
5469     return 0;
5470 }
5471
5472 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5473 {
5474     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5475     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5476
5477     if (!strncmp(arg, "pal-", 4)) {
5478         norm = PAL;
5479         arg += 4;
5480     } else if (!strncmp(arg, "ntsc-", 5)) {
5481         norm = NTSC;
5482         arg += 5;
5483     } else if (!strncmp(arg, "film-", 5)) {
5484         norm = FILM;
5485         arg += 5;
5486     } else {
5487         /* Try to determine PAL/NTSC by peeking in the input files */
5488         if (nb_input_files) {
5489             int i, j, fr;
5490             for (j = 0; j < nb_input_files; j++) {
5491                 for (i = 0; i < input_files[j]->nb_streams; i++) {
5492                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5493                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5494                         continue;
5495                     fr = c->time_base.den * 1000 / c->time_base.num;
5496                     if (fr == 25000) {
5497                         norm = PAL;
5498                         break;
5499                     } else if ((fr == 29970) || (fr == 23976)) {
5500                         norm = NTSC;
5501                         break;
5502                     }
5503                 }
5504                 if (norm != UNKNOWN)
5505                     break;
5506             }
5507         }
5508         if (norm != UNKNOWN)
5509             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5510     }
5511
5512     if (norm == UNKNOWN) {
5513         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5514         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5515         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5516         exit_program(1);
5517     }
5518
5519     if (!strcmp(arg, "vcd")) {
5520         opt_video_codec(o, "c:v", "mpeg1video");
5521         opt_audio_codec(o, "c:a", "mp2");
5522         parse_option(o, "f", "vcd", options);
5523
5524         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5525         parse_option(o, "r", frame_rates[norm], options);
5526         opt_default("g", norm == PAL ? "15" : "18");
5527
5528         opt_default("b:v", "1150000");
5529         opt_default("maxrate", "1150000");
5530         opt_default("minrate", "1150000");
5531         opt_default("bufsize", "327680"); // 40*1024*8;
5532
5533         opt_default("b:a", "224000");
5534         parse_option(o, "ar", "44100", options);
5535         parse_option(o, "ac", "2", options);
5536
5537         opt_default("packetsize", "2324");
5538         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5539
5540         /* We have to offset the PTS, so that it is consistent with the SCR.
5541            SCR starts at 36000, but the first two packs contain only padding
5542            and the first pack from the other stream, respectively, may also have
5543            been written before.
5544            So the real data starts at SCR 36000+3*1200. */
5545         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5546     } else if (!strcmp(arg, "svcd")) {
5547
5548         opt_video_codec(o, "c:v", "mpeg2video");
5549         opt_audio_codec(o, "c:a", "mp2");
5550         parse_option(o, "f", "svcd", options);
5551
5552         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5553         parse_option(o, "r", frame_rates[norm], options);
5554         parse_option(o, "pix_fmt", "yuv420p", options);
5555         opt_default("g", norm == PAL ? "15" : "18");
5556
5557         opt_default("b:v", "2040000");
5558         opt_default("maxrate", "2516000");
5559         opt_default("minrate", "0"); // 1145000;
5560         opt_default("bufsize", "1835008"); // 224*1024*8;
5561         opt_default("scan_offset", "1");
5562
5563
5564         opt_default("b:a", "224000");
5565         parse_option(o, "ar", "44100", options);
5566
5567         opt_default("packetsize", "2324");
5568
5569     } else if (!strcmp(arg, "dvd")) {
5570
5571         opt_video_codec(o, "c:v", "mpeg2video");
5572         opt_audio_codec(o, "c:a", "ac3");
5573         parse_option(o, "f", "dvd", options);
5574
5575         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5576         parse_option(o, "r", frame_rates[norm], options);
5577         parse_option(o, "pix_fmt", "yuv420p", options);
5578         opt_default("g", norm == PAL ? "15" : "18");
5579
5580         opt_default("b:v", "6000000");
5581         opt_default("maxrate", "9000000");
5582         opt_default("minrate", "0"); // 1500000;
5583         opt_default("bufsize", "1835008"); // 224*1024*8;
5584
5585         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5586         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5587
5588         opt_default("b:a", "448000");
5589         parse_option(o, "ar", "48000", options);
5590
5591     } else if (!strncmp(arg, "dv", 2)) {
5592
5593         parse_option(o, "f", "dv", options);
5594
5595         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5596         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5597                           norm == PAL ? "yuv420p" : "yuv411p", options);
5598         parse_option(o, "r", frame_rates[norm], options);
5599
5600         parse_option(o, "ar", "48000", options);
5601         parse_option(o, "ac", "2", options);
5602
5603     } else {
5604         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5605         return AVERROR(EINVAL);
5606     }
5607     return 0;
5608 }
5609
5610 static int opt_vstats_file(const char *opt, const char *arg)
5611 {
5612     av_free (vstats_filename);
5613     vstats_filename = av_strdup (arg);
5614     return 0;
5615 }
5616
5617 static int opt_vstats(const char *opt, const char *arg)
5618 {
5619     char filename[40];
5620     time_t today2 = time(NULL);
5621     struct tm *today = localtime(&today2);
5622
5623     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5624              today->tm_sec);
5625     return opt_vstats_file(opt, filename);
5626 }
5627
5628 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5629 {
5630     return parse_option(o, "frames:v", arg, options);
5631 }
5632
5633 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5634 {
5635     return parse_option(o, "frames:a", arg, options);
5636 }
5637
5638 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5639 {
5640     return parse_option(o, "frames:d", arg, options);
5641 }
5642
5643 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5644 {
5645     FILE *f=NULL;
5646     char filename[1000], line[1000], tmp_line[1000];
5647     const char *codec_name = *opt == 'v' ? video_codec_name :
5648                              *opt == 'a' ? audio_codec_name :
5649                                            subtitle_codec_name;
5650
5651     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5652         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5653             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5654         }else
5655             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5656         exit_program(1);
5657     }
5658
5659     while (fgets(line, sizeof(line), f)) {
5660         char *key = tmp_line, *value, *endptr;
5661
5662         if (strcspn(line, "#\n\r") == 0)
5663             continue;
5664         strcpy(tmp_line, line);
5665         if (!av_strtok(key,   "=",    &value) ||
5666             !av_strtok(value, "\r\n", &endptr)) {
5667             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5668             exit_program(1);
5669         }
5670         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5671
5672         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
5673         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
5674         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5675         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
5676         else if (opt_default(key, value) < 0) {
5677             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5678                    filename, line, key, value);
5679             exit_program(1);
5680         }
5681     }
5682
5683     fclose(f);
5684
5685     return 0;
5686 }
5687
5688 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5689 {
5690 }
5691
5692 static int opt_passlogfile(const char *opt, const char *arg)
5693 {
5694     pass_logfilename_prefix = arg;
5695 #if CONFIG_LIBX264_ENCODER
5696     return opt_default(opt, arg);
5697 #else
5698     return 0;
5699 #endif
5700 }
5701
5702 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5703 {
5704     char *s = av_asprintf("%s:%c", opt + 1, *opt);
5705     int ret = parse_option(o, s, arg, options);
5706     av_free(s);
5707     return ret;
5708 }
5709
5710 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5711 {
5712     if(!strcmp(opt, "b")){
5713         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5714         return parse_option(o, "b:v", arg, options);
5715     }
5716     return opt_default(opt, arg);
5717 }
5718
5719 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5720 {
5721     char *s;
5722     int ret;
5723     if(!strcmp(opt, "qscale")){
5724         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5725         return parse_option(o, "q:v", arg, options);
5726     }
5727     s = av_asprintf("q%s", opt + 6);
5728     ret = parse_option(o, s, arg, options);
5729     av_free(s);
5730     return ret;
5731 }
5732
5733 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5734 {
5735     if(!strcmp(opt, "profile")){
5736         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5737         return parse_option(o, "profile:v", arg, options);
5738     }
5739     return opt_default(opt, arg);
5740 }
5741
5742 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5743 {
5744     return parse_option(o, "filter:v", arg, options);
5745 }
5746
5747 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5748 {
5749     return parse_option(o, "filter:a", arg, options);
5750 }
5751
5752 static int opt_vsync(const char *opt, const char *arg)
5753 {
5754     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
5755     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
5756     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5757     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
5758
5759     if (video_sync_method == VSYNC_AUTO)
5760         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5761     return 0;
5762 }
5763
5764 static int opt_deinterlace(const char *opt, const char *arg)
5765 {
5766     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5767     do_deinterlace = 1;
5768     return 0;
5769 }
5770
5771 static int opt_timecode(OptionsContext *o, const char *opt, const char *arg)
5772 {
5773     char *tcr = av_asprintf("timecode=%s", arg);
5774     int ret = parse_option(o, "metadata:g", tcr, options);
5775     if (ret >= 0)
5776         ret = opt_default("gop_timecode", arg);
5777     av_free(tcr);
5778     return ret;
5779 }
5780
5781 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5782 {
5783     int idx = locate_option(argc, argv, options, "cpuflags");
5784     if (idx && argv[idx + 1])
5785         opt_cpuflags("cpuflags", argv[idx + 1]);
5786 }
5787
5788 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5789 {
5790     char layout_str[32];
5791     char *stream_str;
5792     char *ac_str;
5793     int ret, channels, ac_str_size;
5794     uint64_t layout;
5795
5796     layout = av_get_channel_layout(arg);
5797     if (!layout) {
5798         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5799         return AVERROR(EINVAL);
5800     }
5801     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5802     ret = opt_default(opt, layout_str);
5803     if (ret < 0)
5804         return ret;
5805
5806     /* set 'ac' option based on channel layout */
5807     channels = av_get_channel_layout_nb_channels(layout);
5808     snprintf(layout_str, sizeof(layout_str), "%d", channels);
5809     stream_str = strchr(opt, ':');
5810     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5811     ac_str = av_mallocz(ac_str_size);
5812     if (!ac_str)
5813         return AVERROR(ENOMEM);
5814     av_strlcpy(ac_str, "ac", 3);
5815     if (stream_str)
5816         av_strlcat(ac_str, stream_str, ac_str_size);
5817     ret = parse_option(o, ac_str, layout_str, options);
5818     av_free(ac_str);
5819
5820     return ret;
5821 }
5822
5823 static int opt_filter_complex(const char *opt, const char *arg)
5824 {
5825     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5826                               &nb_filtergraphs, nb_filtergraphs + 1);
5827     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5828         return AVERROR(ENOMEM);
5829     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
5830     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5831     return 0;
5832 }
5833
5834 static int opt_progress(const char *opt, const char *arg)
5835 {
5836     AVIOContext *avio = NULL;
5837     int ret;
5838
5839     if (!strcmp(arg, "-"))
5840         arg = "pipe:";
5841     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
5842     if (ret < 0) {
5843         av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
5844                arg, av_err2str(ret));
5845         return ret;
5846     }
5847     progress_avio = avio;
5848     return 0;
5849 }
5850
5851 #define OFFSET(x) offsetof(OptionsContext, x)
5852 static const OptionDef options[] = {
5853     /* main options */
5854 #include "cmdutils_common_opts.h"
5855     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5856     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5857     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5858     { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5859     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5860     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5861     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5862     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5863     { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
5864     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5865       "outfile[,metadata]:infile[,metadata]" },
5866     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
5867     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5868     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5869     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5870     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5871     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5872     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5873     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5874     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5875     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5876       "add timings for benchmarking" },
5877     { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5878       "add timings for each task" },
5879     { "progress", HAS_ARG | OPT_EXPERT, {(void*)opt_progress},
5880       "write program-readable progress information", "url" },
5881     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5882     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5883       "dump each input packet" },
5884     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5885       "when dumping packets, also dump the payload" },
5886     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5887     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5888     { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5889     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5890     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5891     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
5892     { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying", "mode" },
5893     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5894     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5895     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5896     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5897     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5898     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5899     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5900     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5901     { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5902     { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5903     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5904     { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5905     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5906     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5907     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5908     { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5909
5910     /* video options */
5911     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5912     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5913     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5914     { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
5915     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5916     { "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" },
5917     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5918     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5919     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5920     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5921     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5922     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5923     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5924     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5925     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5926     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5927     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5928     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5929     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5930     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5931     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5932     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5933       "use same quantizer as source (implies VBR)" },
5934     { "timecode", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_timecode}, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
5935     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5936     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5937     { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5938       "this option is deprecated, use the yadif filter instead" },
5939     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5940     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5941     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5942     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5943     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5944     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5945     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5946     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5947     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5948     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5949     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5950     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5951     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
5952     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5953
5954     /* audio options */
5955     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5956     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5957     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5958     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5959     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5960     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5961     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5962     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5963     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5964     { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5965     { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
5966
5967     /* subtitle options */
5968     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5969     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5970     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5971
5972     /* grab options */
5973     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5974     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5975     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5976
5977     /* muxer options */
5978     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5979     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
5980
5981     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5982     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5983     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5984
5985     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5986     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5987     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5988     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5989     /* data codec support */
5990     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5991     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5992
5993     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5994     { NULL, },
5995 };
5996
5997 int main(int argc, char **argv)
5998 {
5999     OptionsContext o = { 0 };
6000     int64_t ti;
6001
6002     reset_options(&o, 0);
6003
6004     av_log_set_flags(AV_LOG_SKIP_REPEATED);
6005     parse_loglevel(argc, argv, options);
6006
6007     if(argc>1 && !strcmp(argv[1], "-d")){
6008         run_as_daemon=1;
6009         av_log_set_callback(log_callback_null);
6010         argc--;
6011         argv++;
6012     }
6013
6014     avcodec_register_all();
6015 #if CONFIG_AVDEVICE
6016     avdevice_register_all();
6017 #endif
6018     avfilter_register_all();
6019     av_register_all();
6020     avformat_network_init();
6021
6022     show_banner(argc, argv, options);
6023
6024     term_init();
6025
6026     parse_cpuflags(argc, argv, options);
6027
6028     /* parse options */
6029     parse_options(&o, argc, argv, options, opt_output_file);
6030
6031     if (nb_output_files <= 0 && nb_input_files == 0) {
6032         show_usage();
6033         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
6034         exit_program(1);
6035     }
6036
6037     /* file converter / grab */
6038     if (nb_output_files <= 0) {
6039         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
6040         exit_program(1);
6041     }
6042
6043     if (nb_input_files == 0) {
6044         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
6045         exit_program(1);
6046     }
6047
6048     current_time = ti = getutime();
6049     if (transcode() < 0)
6050         exit_program(1);
6051     ti = getutime() - ti;
6052     if (do_benchmark) {
6053         int maxrss = getmaxrss() / 1024;
6054         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
6055     }
6056
6057     exit_program(0);
6058     return 0;
6059 }