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 = 1, av_uninit(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         if (!nb_success) /* from last round */
2005             break;
2006         /* Request frames through all the graphs */
2007         ret_all = nb_success = nb_eof = 0;
2008         for (i = 0; i < nb_filtergraphs; i++) {
2009             ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2010             if (!ret) {
2011                 nb_success++;
2012             } else if (ret == AVERROR_EOF) {
2013                 nb_eof++;
2014             } else if (ret != AVERROR(EAGAIN)) {
2015                 char buf[256];
2016                 av_strerror(ret, buf, sizeof(buf));
2017                 av_log(NULL, AV_LOG_WARNING,
2018                        "Error in request_frame(): %s\n", buf);
2019                 ret_all = ret;
2020             }
2021         }
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
2396     update_benchmark(NULL);
2397     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2398     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2399     if (ret < 0) {
2400         return ret;
2401     }
2402     if (avctx->sample_rate <= 0) {
2403         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2404         return AVERROR_INVALIDDATA;
2405     }
2406
2407     if (!*got_output) {
2408         /* no audio frame */
2409         if (!pkt->size)
2410             for (i = 0; i < ist->nb_filters; i++)
2411                 av_buffersrc_add_ref(ist->filters[i]->filter, NULL,
2412                                      AV_BUFFERSRC_FLAG_NO_COPY);
2413         return ret;
2414     }
2415
2416     /* if the decoder provides a pts, use it instead of the last packet pts.
2417        the decoder could be delaying output by a packet or more. */
2418     if (decoded_frame->pts != AV_NOPTS_VALUE)
2419         ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2420     else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
2421         decoded_frame->pts = decoded_frame->pkt_pts;
2422         pkt->pts           = AV_NOPTS_VALUE;
2423     } else if (pkt->pts != AV_NOPTS_VALUE) {
2424         decoded_frame->pts = pkt->pts;
2425         pkt->pts           = AV_NOPTS_VALUE;
2426     }else
2427         decoded_frame->pts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2428
2429
2430 #if 1
2431     /* increment next_dts to use for the case where the input stream does not
2432        have timestamps or there are multiple frames in the packet */
2433     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2434                      avctx->sample_rate;
2435     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2436                      avctx->sample_rate;
2437 #endif
2438
2439     rate_emu_sleep(ist);
2440
2441     resample_changed = ist->resample_sample_fmt     != decoded_frame->format         ||
2442                        ist->resample_channels       != avctx->channels               ||
2443                        ist->resample_channel_layout != decoded_frame->channel_layout ||
2444                        ist->resample_sample_rate    != decoded_frame->sample_rate;
2445     if (resample_changed) {
2446         char layout1[64], layout2[64];
2447
2448         if (!guess_input_channel_layout(ist)) {
2449             av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2450                    "layout for Input Stream #%d.%d\n", ist->file_index,
2451                    ist->st->index);
2452             exit_program(1);
2453         }
2454         decoded_frame->channel_layout = avctx->channel_layout;
2455
2456         av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2457                                      ist->resample_channel_layout);
2458         av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2459                                      decoded_frame->channel_layout);
2460
2461         av_log(NULL, AV_LOG_INFO,
2462                "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",
2463                ist->file_index, ist->st->index,
2464                ist->resample_sample_rate,  av_get_sample_fmt_name(ist->resample_sample_fmt),
2465                ist->resample_channels, layout1,
2466                decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2467                avctx->channels, layout2);
2468
2469         ist->resample_sample_fmt     = decoded_frame->format;
2470         ist->resample_sample_rate    = decoded_frame->sample_rate;
2471         ist->resample_channel_layout = decoded_frame->channel_layout;
2472         ist->resample_channels       = avctx->channels;
2473
2474         for (i = 0; i < nb_filtergraphs; i++)
2475             if (ist_in_filtergraph(filtergraphs[i], ist)) {
2476                 FilterGraph *fg = filtergraphs[i];
2477                 int j;
2478                 if (configure_filtergraph(fg) < 0) {
2479                     av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2480                     exit_program(1);
2481                 }
2482                 for (j = 0; j < fg->nb_outputs; j++) {
2483                     OutputStream *ost = fg->outputs[j]->ost;
2484                     if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2485                         !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
2486                         av_buffersink_set_frame_size(ost->filter->filter,
2487                                                      ost->st->codec->frame_size);
2488                 }
2489             }
2490     }
2491
2492     if (decoded_frame->pts != AV_NOPTS_VALUE)
2493         decoded_frame->pts = av_rescale_q(decoded_frame->pts,
2494                                           ist->st->time_base,
2495                                           (AVRational){1, ist->st->codec->sample_rate});
2496     for (i = 0; i < ist->nb_filters; i++)
2497         av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
2498
2499     return ret;
2500 }
2501
2502 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2503 {
2504     AVFrame *decoded_frame;
2505     void *buffer_to_free = NULL;
2506     int i, ret = 0, resample_changed;
2507     int64_t best_effort_timestamp;
2508     AVRational *frame_sample_aspect;
2509     float quality;
2510
2511     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2512         return AVERROR(ENOMEM);
2513     else
2514         avcodec_get_frame_defaults(ist->decoded_frame);
2515     decoded_frame = ist->decoded_frame;
2516     pkt->dts  = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2517
2518     update_benchmark(NULL);
2519     ret = avcodec_decode_video2(ist->st->codec,
2520                                 decoded_frame, got_output, pkt);
2521     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2522     if (ret < 0)
2523         return ret;
2524
2525     quality = same_quant ? decoded_frame->quality : 0;
2526     if (!*got_output) {
2527         /* no picture yet */
2528         if (!pkt->size)
2529             for (i = 0; i < ist->nb_filters; i++)
2530                 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, AV_BUFFERSRC_FLAG_NO_COPY);
2531         return ret;
2532     }
2533
2534     if(ist->top_field_first>=0)
2535         decoded_frame->top_field_first = ist->top_field_first;
2536
2537     best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2538     if(best_effort_timestamp != AV_NOPTS_VALUE)
2539         ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2540
2541     if (debug_ts) {
2542         av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2543                 "frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64" best_effort_ts_time:%s keyframe:%d frame_type:%d \n",
2544                 ist->st->index, av_ts2str(decoded_frame->pts),
2545                 av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2546                 best_effort_timestamp,
2547                 av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2548                 decoded_frame->key_frame, decoded_frame->pict_type);
2549     }
2550
2551     pkt->size = 0;
2552     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2553
2554     rate_emu_sleep(ist);
2555
2556     if (ist->st->sample_aspect_ratio.num)
2557         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2558
2559     resample_changed = ist->resample_width   != decoded_frame->width  ||
2560                        ist->resample_height  != decoded_frame->height ||
2561                        ist->resample_pix_fmt != decoded_frame->format;
2562     if (resample_changed) {
2563         av_log(NULL, AV_LOG_INFO,
2564                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2565                ist->file_index, ist->st->index,
2566                ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
2567                decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2568
2569         ist->resample_width   = decoded_frame->width;
2570         ist->resample_height  = decoded_frame->height;
2571         ist->resample_pix_fmt = decoded_frame->format;
2572
2573         for (i = 0; i < nb_filtergraphs; i++)
2574             if (ist_in_filtergraph(filtergraphs[i], ist) &&
2575                 configure_filtergraph(filtergraphs[i]) < 0) {
2576                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2577                 exit_program(1);
2578             }
2579     }
2580
2581     frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2582     for (i = 0; i < ist->nb_filters; i++) {
2583         int changed =      ist->st->codec->width   != ist->filters[i]->filter->outputs[0]->w
2584                         || ist->st->codec->height  != ist->filters[i]->filter->outputs[0]->h
2585                         || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2586         // XXX what an ugly hack
2587         if (ist->filters[i]->graph->nb_outputs == 1)
2588             ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2589
2590         if (!frame_sample_aspect->num)
2591             *frame_sample_aspect = ist->st->sample_aspect_ratio;
2592         if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2593             FrameBuffer      *buf = decoded_frame->opaque;
2594             AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2595                                         decoded_frame->data, decoded_frame->linesize,
2596                                         AV_PERM_READ | AV_PERM_PRESERVE,
2597                                         ist->st->codec->width, ist->st->codec->height,
2598                                         ist->st->codec->pix_fmt);
2599
2600             avfilter_copy_frame_props(fb, decoded_frame);
2601             fb->buf->priv           = buf;
2602             fb->buf->free           = filter_release_buffer;
2603
2604             av_assert0(buf->refcount>0);
2605             buf->refcount++;
2606             av_buffersrc_add_ref(ist->filters[i]->filter, fb,
2607                                  AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
2608                                  AV_BUFFERSRC_FLAG_NO_COPY);
2609         } else
2610         if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
2611             av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2612             exit_program(1);
2613         }
2614
2615     }
2616
2617     av_free(buffer_to_free);
2618     return ret;
2619 }
2620
2621 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2622 {
2623     AVSubtitle subtitle;
2624     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2625                                           &subtitle, got_output, pkt);
2626     if (ret < 0)
2627         return ret;
2628     if (!*got_output)
2629         return ret;
2630
2631     rate_emu_sleep(ist);
2632
2633     for (i = 0; i < nb_output_streams; i++) {
2634         OutputStream *ost = output_streams[i];
2635
2636         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2637             continue;
2638
2639         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2640     }
2641
2642     avsubtitle_free(&subtitle);
2643     return ret;
2644 }
2645
2646 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2647 static int output_packet(InputStream *ist, const AVPacket *pkt)
2648 {
2649     int ret = 0, i;
2650     int got_output;
2651
2652     AVPacket avpkt;
2653     if (!ist->saw_first_ts) {
2654         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;
2655         ist->pts = 0;
2656         if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2657             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2658             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2659         }
2660         ist->saw_first_ts = 1;
2661     }
2662
2663     if (ist->next_dts == AV_NOPTS_VALUE)
2664         ist->next_dts = ist->dts;
2665     if (ist->next_pts == AV_NOPTS_VALUE)
2666         ist->next_pts = ist->pts;
2667
2668     if (pkt == NULL) {
2669         /* EOF handling */
2670         av_init_packet(&avpkt);
2671         avpkt.data = NULL;
2672         avpkt.size = 0;
2673         goto handle_eof;
2674     } else {
2675         avpkt = *pkt;
2676     }
2677
2678     if (pkt->dts != AV_NOPTS_VALUE) {
2679         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2680         if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2681             ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2682     }
2683
2684     // while we have more to decode or while the decoder did output something on EOF
2685     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2686         int duration;
2687     handle_eof:
2688
2689         ist->pts = ist->next_pts;
2690         ist->dts = ist->next_dts;
2691
2692         if (avpkt.size && avpkt.size != pkt->size) {
2693             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2694                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2695             ist->showed_multi_packet_warning = 1;
2696         }
2697
2698         switch (ist->st->codec->codec_type) {
2699         case AVMEDIA_TYPE_AUDIO:
2700             ret = decode_audio    (ist, &avpkt, &got_output);
2701             break;
2702         case AVMEDIA_TYPE_VIDEO:
2703             ret = decode_video    (ist, &avpkt, &got_output);
2704             if (avpkt.duration) {
2705                 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2706             } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2707                 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2708                 duration = ((int64_t)AV_TIME_BASE *
2709                                 ist->st->codec->time_base.num * ticks) /
2710                                 ist->st->codec->time_base.den;
2711             } else
2712                 duration = 0;
2713
2714             if(ist->dts != AV_NOPTS_VALUE && duration) {
2715                 ist->next_dts += duration;
2716             }else
2717                 ist->next_dts = AV_NOPTS_VALUE;
2718
2719             if (got_output)
2720                 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2721             break;
2722         case AVMEDIA_TYPE_SUBTITLE:
2723             ret = transcode_subtitles(ist, &avpkt, &got_output);
2724             break;
2725         default:
2726             return -1;
2727         }
2728
2729         if (ret < 0)
2730             return ret;
2731
2732         avpkt.dts=
2733         avpkt.pts= AV_NOPTS_VALUE;
2734
2735         // touch data and size only if not EOF
2736         if (pkt) {
2737             if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2738                 ret = avpkt.size;
2739             avpkt.data += ret;
2740             avpkt.size -= ret;
2741         }
2742         if (!got_output) {
2743             continue;
2744         }
2745     }
2746
2747     /* handle stream copy */
2748     if (!ist->decoding_needed) {
2749         rate_emu_sleep(ist);
2750         ist->dts = ist->next_dts;
2751         switch (ist->st->codec->codec_type) {
2752         case AVMEDIA_TYPE_AUDIO:
2753             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2754                              ist->st->codec->sample_rate;
2755             break;
2756         case AVMEDIA_TYPE_VIDEO:
2757             if (pkt->duration) {
2758                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2759             } else if(ist->st->codec->time_base.num != 0) {
2760                 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2761                 ist->next_dts += ((int64_t)AV_TIME_BASE *
2762                                   ist->st->codec->time_base.num * ticks) /
2763                                   ist->st->codec->time_base.den;
2764             }
2765             break;
2766         }
2767         ist->pts = ist->dts;
2768         ist->next_pts = ist->next_dts;
2769     }
2770     for (i = 0; pkt && i < nb_output_streams; i++) {
2771         OutputStream *ost = output_streams[i];
2772
2773         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2774             continue;
2775
2776         do_streamcopy(ist, ost, pkt);
2777     }
2778
2779     return 0;
2780 }
2781
2782 static void print_sdp(void)
2783 {
2784     char sdp[2048];
2785     int i;
2786     AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2787
2788     if (!avc)
2789         exit_program(1);
2790     for (i = 0; i < nb_output_files; i++)
2791         avc[i] = output_files[i]->ctx;
2792
2793     av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2794     printf("SDP:\n%s\n", sdp);
2795     fflush(stdout);
2796     av_freep(&avc);
2797 }
2798
2799 static int init_input_stream(int ist_index, char *error, int error_len)
2800 {
2801     InputStream *ist = input_streams[ist_index];
2802
2803     if (ist->decoding_needed) {
2804         AVCodec *codec = ist->dec;
2805         if (!codec) {
2806             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2807                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2808             return AVERROR(EINVAL);
2809         }
2810
2811         ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
2812         if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2813             ist->st->codec->get_buffer     = codec_get_buffer;
2814             ist->st->codec->release_buffer = codec_release_buffer;
2815             ist->st->codec->opaque         = &ist->buffer_pool;
2816         }
2817
2818         if (!av_dict_get(ist->opts, "threads", NULL, 0))
2819             av_dict_set(&ist->opts, "threads", "auto", 0);
2820         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2821             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2822                     ist->file_index, ist->st->index);
2823             return AVERROR(EINVAL);
2824         }
2825         assert_codec_experimental(ist->st->codec, 0);
2826         assert_avoptions(ist->opts);
2827     }
2828
2829     ist->next_pts = AV_NOPTS_VALUE;
2830     ist->next_dts = AV_NOPTS_VALUE;
2831     ist->is_start = 1;
2832
2833     return 0;
2834 }
2835
2836 static InputStream *get_input_stream(OutputStream *ost)
2837 {
2838     if (ost->source_index >= 0)
2839         return input_streams[ost->source_index];
2840     return NULL;
2841 }
2842
2843 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2844                                     AVCodecContext *avctx)
2845 {
2846     char *p;
2847     int n = 1, i;
2848     int64_t t;
2849
2850     for (p = kf; *p; p++)
2851         if (*p == ',')
2852             n++;
2853     ost->forced_kf_count = n;
2854     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2855     if (!ost->forced_kf_pts) {
2856         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2857         exit_program(1);
2858     }
2859
2860     p = kf;
2861     for (i = 0; i < n; i++) {
2862         char *next = strchr(p, ',');
2863
2864         if (next)
2865             *next++ = 0;
2866
2867         t = parse_time_or_die("force_key_frames", p, 1);
2868         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2869
2870         p = next;
2871     }
2872 }
2873
2874 static int transcode_init(void)
2875 {
2876     int ret = 0, i, j, k;
2877     AVFormatContext *oc;
2878     AVCodecContext *codec, *icodec = NULL;
2879     OutputStream *ost;
2880     InputStream *ist;
2881     char error[1024];
2882     int want_sdp = 1;
2883
2884     /* init framerate emulation */
2885     for (i = 0; i < nb_input_files; i++) {
2886         InputFile *ifile = input_files[i];
2887         if (ifile->rate_emu)
2888             for (j = 0; j < ifile->nb_streams; j++)
2889                 input_streams[j + ifile->ist_index]->start = av_gettime();
2890     }
2891
2892     /* output stream init */
2893     for (i = 0; i < nb_output_files; i++) {
2894         oc = output_files[i]->ctx;
2895         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2896             av_dump_format(oc, i, oc->filename, 1);
2897             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2898             return AVERROR(EINVAL);
2899         }
2900     }
2901
2902     /* init complex filtergraphs */
2903     for (i = 0; i < nb_filtergraphs; i++)
2904         if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2905             return ret;
2906
2907     /* for each output stream, we compute the right encoding parameters */
2908     for (i = 0; i < nb_output_streams; i++) {
2909         ost = output_streams[i];
2910         oc  = output_files[ost->file_index]->ctx;
2911         ist = get_input_stream(ost);
2912
2913         if (ost->attachment_filename)
2914             continue;
2915
2916         codec  = ost->st->codec;
2917
2918         if (ist) {
2919             icodec = ist->st->codec;
2920
2921             ost->st->disposition          = ist->st->disposition;
2922             codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
2923             codec->chroma_sample_location = icodec->chroma_sample_location;
2924         }
2925
2926         if (ost->stream_copy) {
2927             uint64_t extra_size;
2928
2929             av_assert0(ist && !ost->filter);
2930
2931             extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2932
2933             if (extra_size > INT_MAX) {
2934                 return AVERROR(EINVAL);
2935             }
2936
2937             /* if stream_copy is selected, no need to decode or encode */
2938             codec->codec_id   = icodec->codec_id;
2939             codec->codec_type = icodec->codec_type;
2940
2941             if (!codec->codec_tag) {
2942                 if (!oc->oformat->codec_tag ||
2943                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2944                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2945                     codec->codec_tag = icodec->codec_tag;
2946             }
2947
2948             codec->bit_rate       = icodec->bit_rate;
2949             codec->rc_max_rate    = icodec->rc_max_rate;
2950             codec->rc_buffer_size = icodec->rc_buffer_size;
2951             codec->field_order    = icodec->field_order;
2952             codec->extradata      = av_mallocz(extra_size);
2953             if (!codec->extradata) {
2954                 return AVERROR(ENOMEM);
2955             }
2956             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2957             codec->extradata_size= icodec->extradata_size;
2958             codec->bits_per_coded_sample  = icodec->bits_per_coded_sample;
2959
2960             codec->time_base = ist->st->time_base;
2961             /*
2962              * Avi is a special case here because it supports variable fps but
2963              * having the fps and timebase differe significantly adds quite some
2964              * overhead
2965              */
2966             if(!strcmp(oc->oformat->name, "avi")) {
2967                 if (   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2968                                  && av_q2d(ist->st->time_base) < 1.0/500
2969                     || copy_tb==0){
2970                     codec->time_base = icodec->time_base;
2971                     codec->time_base.num *= icodec->ticks_per_frame;
2972                     codec->time_base.den *= 2;
2973                     codec->ticks_per_frame = 2;
2974                 }
2975             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2976                       && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2977                       && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2978             ) {
2979                 if(   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2980                                 && av_q2d(ist->st->time_base) < 1.0/500
2981                    || copy_tb==0){
2982                     codec->time_base = icodec->time_base;
2983                     codec->time_base.num *= icodec->ticks_per_frame;
2984                 }
2985             }
2986
2987             if(ost->frame_rate.num)
2988                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2989
2990             av_reduce(&codec->time_base.num, &codec->time_base.den,
2991                         codec->time_base.num, codec->time_base.den, INT_MAX);
2992
2993             switch (codec->codec_type) {
2994             case AVMEDIA_TYPE_AUDIO:
2995                 if (audio_volume != 256) {
2996                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2997                     exit_program(1);
2998                 }
2999                 codec->channel_layout     = icodec->channel_layout;
3000                 codec->sample_rate        = icodec->sample_rate;
3001                 codec->channels           = icodec->channels;
3002                 codec->frame_size         = icodec->frame_size;
3003                 codec->audio_service_type = icodec->audio_service_type;
3004                 codec->block_align        = icodec->block_align;
3005                 if((codec->block_align == 1 || codec->block_align == 1152) && codec->codec_id == CODEC_ID_MP3)
3006                     codec->block_align= 0;
3007                 if(codec->codec_id == CODEC_ID_AC3)
3008                     codec->block_align= 0;
3009                 break;
3010             case AVMEDIA_TYPE_VIDEO:
3011                 codec->pix_fmt            = icodec->pix_fmt;
3012                 codec->width              = icodec->width;
3013                 codec->height             = icodec->height;
3014                 codec->has_b_frames       = icodec->has_b_frames;
3015                 if (!codec->sample_aspect_ratio.num) {
3016                     codec->sample_aspect_ratio   =
3017                     ost->st->sample_aspect_ratio =
3018                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
3019                         ist->st->codec->sample_aspect_ratio.num ?
3020                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3021                 }
3022                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3023                 break;
3024             case AVMEDIA_TYPE_SUBTITLE:
3025                 codec->width  = icodec->width;
3026                 codec->height = icodec->height;
3027                 break;
3028             case AVMEDIA_TYPE_DATA:
3029             case AVMEDIA_TYPE_ATTACHMENT:
3030                 break;
3031             default:
3032                 abort();
3033             }
3034         } else {
3035             if (!ost->enc)
3036                 ost->enc = avcodec_find_encoder(codec->codec_id);
3037             if (!ost->enc) {
3038                 /* should only happen when a default codec is not present. */
3039                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3040                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3041                 ret = AVERROR(EINVAL);
3042                 goto dump_format;
3043             }
3044
3045             if (ist)
3046                 ist->decoding_needed = 1;
3047             ost->encoding_needed = 1;
3048
3049             if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3050                 if (ost->filter && !ost->frame_rate.num)
3051                     ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3052                 if (ist && !ost->frame_rate.num)
3053                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
3054                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3055                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3056                     ost->frame_rate = ost->enc->supported_framerates[idx];
3057                 }
3058             }
3059
3060             if (!ost->filter &&
3061                 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3062                  codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
3063                     FilterGraph *fg;
3064                     fg = init_simple_filtergraph(ist, ost);
3065                     if (configure_filtergraph(fg)) {
3066                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3067                         exit(1);
3068                     }
3069             }
3070
3071             switch (codec->codec_type) {
3072             case AVMEDIA_TYPE_AUDIO:
3073                 codec->sample_fmt     = ost->filter->filter->inputs[0]->format;
3074                 codec->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
3075                 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3076                 codec->channels       = av_get_channel_layout_nb_channels(codec->channel_layout);
3077                 codec->time_base      = (AVRational){ 1, codec->sample_rate };
3078                 break;
3079             case AVMEDIA_TYPE_VIDEO:
3080                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3081                 if (ost->filter && !(codec->time_base.num && codec->time_base.den))
3082                     codec->time_base = ost->filter->filter->inputs[0]->time_base;
3083                 if (   av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3084                    && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3085                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3086                                                "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3087                 }
3088                 for (j = 0; j < ost->forced_kf_count; j++)
3089                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3090                                                          AV_TIME_BASE_Q,
3091                                                          codec->time_base);
3092
3093                 codec->width  = ost->filter->filter->inputs[0]->w;
3094                 codec->height = ost->filter->filter->inputs[0]->h;
3095                 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3096                     ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3097                     av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3098                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
3099                 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3100
3101                 if (!icodec ||
3102                     codec->width   != icodec->width  ||
3103                     codec->height  != icodec->height ||
3104                     codec->pix_fmt != icodec->pix_fmt) {
3105                     codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3106                 }
3107
3108                 if (ost->forced_keyframes)
3109                     parse_forced_key_frames(ost->forced_keyframes, ost,
3110                                             ost->st->codec);
3111                 break;
3112             case AVMEDIA_TYPE_SUBTITLE:
3113                 codec->time_base = (AVRational){1, 1000};
3114                 break;
3115             default:
3116                 abort();
3117                 break;
3118             }
3119             /* two pass mode */
3120             if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3121                 char logfilename[1024];
3122                 FILE *f;
3123
3124                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3125                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3126                          i);
3127                 if (!strcmp(ost->enc->name, "libx264")) {
3128                     av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3129                 } else {
3130                     if (codec->flags & CODEC_FLAG_PASS2) {
3131                         char  *logbuffer;
3132                         size_t logbuffer_size;
3133                         if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3134                             av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3135                                    logfilename);
3136                             exit_program(1);
3137                         }
3138                         codec->stats_in = logbuffer;
3139                     }
3140                     if (codec->flags & CODEC_FLAG_PASS1) {
3141                         f = fopen(logfilename, "wb");
3142                         if (!f) {
3143                             av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3144                                 logfilename, strerror(errno));
3145                             exit_program(1);
3146                         }
3147                         ost->logfile = f;
3148                     }
3149                 }
3150             }
3151         }
3152     }
3153
3154     /* open each encoder */
3155     for (i = 0; i < nb_output_streams; i++) {
3156         ost = output_streams[i];
3157         if (ost->encoding_needed) {
3158             AVCodec      *codec = ost->enc;
3159             AVCodecContext *dec = NULL;
3160
3161             if ((ist = get_input_stream(ost)))
3162                 dec = ist->st->codec;
3163             if (dec && dec->subtitle_header) {
3164                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3165                 if (!ost->st->codec->subtitle_header) {
3166                     ret = AVERROR(ENOMEM);
3167                     goto dump_format;
3168                 }
3169                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3170                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3171             }
3172             if (!av_dict_get(ost->opts, "threads", NULL, 0))
3173                 av_dict_set(&ost->opts, "threads", "auto", 0);
3174             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3175                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3176                         ost->file_index, ost->index);
3177                 ret = AVERROR(EINVAL);
3178                 goto dump_format;
3179             }
3180             if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3181                 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
3182                 av_buffersink_set_frame_size(ost->filter->filter,
3183                                              ost->st->codec->frame_size);
3184             assert_codec_experimental(ost->st->codec, 1);
3185             assert_avoptions(ost->opts);
3186             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3187                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3188                                              " It takes bits/s as argument, not kbits/s\n");
3189             extra_size += ost->st->codec->extradata_size;
3190
3191             if (ost->st->codec->me_threshold)
3192                 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3193         }
3194     }
3195
3196     /* init input streams */
3197     for (i = 0; i < nb_input_streams; i++)
3198         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3199             goto dump_format;
3200
3201     /* discard unused programs */
3202     for (i = 0; i < nb_input_files; i++) {
3203         InputFile *ifile = input_files[i];
3204         for (j = 0; j < ifile->ctx->nb_programs; j++) {
3205             AVProgram *p = ifile->ctx->programs[j];
3206             int discard  = AVDISCARD_ALL;
3207
3208             for (k = 0; k < p->nb_stream_indexes; k++)
3209                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3210                     discard = AVDISCARD_DEFAULT;
3211                     break;
3212                 }
3213             p->discard = discard;
3214         }
3215     }
3216
3217     /* open files and write file headers */
3218     for (i = 0; i < nb_output_files; i++) {
3219         oc = output_files[i]->ctx;
3220         oc->interrupt_callback = int_cb;
3221         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3222             char errbuf[128];
3223             const char *errbuf_ptr = errbuf;
3224             if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
3225                 errbuf_ptr = strerror(AVUNERROR(ret));
3226             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
3227             ret = AVERROR(EINVAL);
3228             goto dump_format;
3229         }
3230 //         assert_avoptions(output_files[i]->opts);
3231         if (strcmp(oc->oformat->name, "rtp")) {
3232             want_sdp = 0;
3233         }
3234     }
3235
3236  dump_format:
3237     /* dump the file output parameters - cannot be done before in case
3238        of stream copy */
3239     for (i = 0; i < nb_output_files; i++) {
3240         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3241     }
3242
3243     /* dump the stream mapping */
3244     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3245     for (i = 0; i < nb_input_streams; i++) {
3246         ist = input_streams[i];
3247
3248         for (j = 0; j < ist->nb_filters; j++) {
3249             if (ist->filters[j]->graph->graph_desc) {
3250                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
3251                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3252                        ist->filters[j]->name);
3253                 if (nb_filtergraphs > 1)
3254                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3255                 av_log(NULL, AV_LOG_INFO, "\n");
3256             }
3257         }
3258     }
3259
3260     for (i = 0; i < nb_output_streams; i++) {
3261         ost = output_streams[i];
3262
3263         if (ost->attachment_filename) {
3264             /* an attached file */
3265             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
3266                    ost->attachment_filename, ost->file_index, ost->index);
3267             continue;
3268         }
3269
3270         if (ost->filter && ost->filter->graph->graph_desc) {
3271             /* output from a complex graph */
3272             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
3273             if (nb_filtergraphs > 1)
3274                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3275
3276             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3277                    ost->index, ost->enc ? ost->enc->name : "?");
3278             continue;
3279         }
3280
3281         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
3282                input_streams[ost->source_index]->file_index,
3283                input_streams[ost->source_index]->st->index,
3284                ost->file_index,
3285                ost->index);
3286         if (ost->sync_ist != input_streams[ost->source_index])
3287             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3288                    ost->sync_ist->file_index,
3289                    ost->sync_ist->st->index);
3290         if (ost->stream_copy)
3291             av_log(NULL, AV_LOG_INFO, " (copy)");
3292         else
3293             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3294                    input_streams[ost->source_index]->dec->name : "?",
3295                    ost->enc ? ost->enc->name : "?");
3296         av_log(NULL, AV_LOG_INFO, "\n");
3297     }
3298
3299     if (ret) {
3300         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3301         return ret;
3302     }
3303
3304     if (want_sdp) {
3305         print_sdp();
3306     }
3307
3308     return 0;
3309 }
3310
3311 /**
3312  * @return 1 if there are still streams where more output is wanted,
3313  *         0 otherwise
3314  */
3315 static int need_output(void)
3316 {
3317     int i;
3318
3319     for (i = 0; i < nb_output_streams; i++) {
3320         OutputStream *ost    = output_streams[i];
3321         OutputFile *of       = output_files[ost->file_index];
3322         AVFormatContext *os  = output_files[ost->file_index]->ctx;
3323
3324         if (ost->is_past_recording_time ||
3325             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3326             continue;
3327         if (ost->frame_number >= ost->max_frames) {
3328             int j;
3329             for (j = 0; j < of->ctx->nb_streams; j++)
3330                 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3331             continue;
3332         }
3333
3334         return 1;
3335     }
3336
3337     return 0;
3338 }
3339
3340 static int select_input_file(uint8_t *no_packet)
3341 {
3342     int64_t ipts_min = INT64_MAX;
3343     int i, file_index = -1;
3344
3345     for (i = 0; i < nb_input_streams; i++) {
3346         InputStream *ist = input_streams[i];
3347         int64_t ipts     = ist->pts;
3348
3349         if (ist->discard || no_packet[ist->file_index])
3350             continue;
3351         if (!input_files[ist->file_index]->eof_reached) {
3352             if (ipts < ipts_min) {
3353                 ipts_min = ipts;
3354                 file_index = ist->file_index;
3355             }
3356         }
3357     }
3358
3359     return file_index;
3360 }
3361
3362 static int check_keyboard_interaction(int64_t cur_time)
3363 {
3364     int i, ret, key;
3365     static int64_t last_time;
3366     if (received_nb_signals)
3367         return AVERROR_EXIT;
3368     /* read_key() returns 0 on EOF */
3369     if(cur_time - last_time >= 100000 && !run_as_daemon){
3370         key =  read_key();
3371         last_time = cur_time;
3372     }else
3373         key = -1;
3374     if (key == 'q')
3375         return AVERROR_EXIT;
3376     if (key == '+') av_log_set_level(av_log_get_level()+10);
3377     if (key == '-') av_log_set_level(av_log_get_level()-10);
3378     if (key == 's') qp_hist     ^= 1;
3379     if (key == 'h'){
3380         if (do_hex_dump){
3381             do_hex_dump = do_pkt_dump = 0;
3382         } else if(do_pkt_dump){
3383             do_hex_dump = 1;
3384         } else
3385             do_pkt_dump = 1;
3386         av_log_set_level(AV_LOG_DEBUG);
3387     }
3388     if (key == 'c' || key == 'C'){
3389         char buf[4096], target[64], command[256], arg[256] = {0};
3390         double time;
3391         int k, n = 0;
3392         fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3393         i = 0;
3394         while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3395             if (k > 0)
3396                 buf[i++] = k;
3397         buf[i] = 0;
3398         if (k > 0 &&
3399             (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3400             av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3401                    target, time, command, arg);
3402             for (i = 0; i < nb_filtergraphs; i++) {
3403                 FilterGraph *fg = filtergraphs[i];
3404                 if (fg->graph) {
3405                     if (time < 0) {
3406                         ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3407                                                           key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3408                         fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3409                     } else {
3410                         ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3411                     }
3412                 }
3413             }
3414         } else {
3415             av_log(NULL, AV_LOG_ERROR,
3416                    "Parse error, at least 3 arguments were expected, "
3417                    "only %d given in string '%s'\n", n, buf);
3418         }
3419     }
3420     if (key == 'd' || key == 'D'){
3421         int debug=0;
3422         if(key == 'D') {
3423             debug = input_streams[0]->st->codec->debug<<1;
3424             if(!debug) debug = 1;
3425             while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3426                 debug += debug;
3427         }else
3428             if(scanf("%d", &debug)!=1)
3429                 fprintf(stderr,"error parsing debug value\n");
3430         for(i=0;i<nb_input_streams;i++) {
3431             input_streams[i]->st->codec->debug = debug;
3432         }
3433         for(i=0;i<nb_output_streams;i++) {
3434             OutputStream *ost = output_streams[i];
3435             ost->st->codec->debug = debug;
3436         }
3437         if(debug) av_log_set_level(AV_LOG_DEBUG);
3438         fprintf(stderr,"debug=%d\n", debug);
3439     }
3440     if (key == '?'){
3441         fprintf(stderr, "key    function\n"
3442                         "?      show this help\n"
3443                         "+      increase verbosity\n"
3444                         "-      decrease verbosity\n"
3445                         "c      Send command to filtergraph\n"
3446                         "D      cycle through available debug modes\n"
3447                         "h      dump packets/hex press to cycle through the 3 states\n"
3448                         "q      quit\n"
3449                         "s      Show QP histogram\n"
3450         );
3451     }
3452     return 0;
3453 }
3454
3455 #if HAVE_PTHREADS
3456 static void *input_thread(void *arg)
3457 {
3458     InputFile *f = arg;
3459     int ret = 0;
3460
3461     while (!transcoding_finished && ret >= 0) {
3462         AVPacket pkt;
3463         ret = av_read_frame(f->ctx, &pkt);
3464
3465         if (ret == AVERROR(EAGAIN)) {
3466             av_usleep(10000);
3467             ret = 0;
3468             continue;
3469         } else if (ret < 0)
3470             break;
3471
3472         pthread_mutex_lock(&f->fifo_lock);
3473         while (!av_fifo_space(f->fifo))
3474             pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
3475
3476         av_dup_packet(&pkt);
3477         av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
3478
3479         pthread_mutex_unlock(&f->fifo_lock);
3480     }
3481
3482     f->finished = 1;
3483     return NULL;
3484 }
3485
3486 static void free_input_threads(void)
3487 {
3488     int i;
3489
3490     if (nb_input_files == 1)
3491         return;
3492
3493     transcoding_finished = 1;
3494
3495     for (i = 0; i < nb_input_files; i++) {
3496         InputFile *f = input_files[i];
3497         AVPacket pkt;
3498
3499         if (!f->fifo || f->joined)
3500             continue;
3501
3502         pthread_mutex_lock(&f->fifo_lock);
3503         while (av_fifo_size(f->fifo)) {
3504             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3505             av_free_packet(&pkt);
3506         }
3507         pthread_cond_signal(&f->fifo_cond);
3508         pthread_mutex_unlock(&f->fifo_lock);
3509
3510         pthread_join(f->thread, NULL);
3511         f->joined = 1;
3512
3513         while (av_fifo_size(f->fifo)) {
3514             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3515             av_free_packet(&pkt);
3516         }
3517         av_fifo_free(f->fifo);
3518     }
3519 }
3520
3521 static int init_input_threads(void)
3522 {
3523     int i, ret;
3524
3525     if (nb_input_files == 1)
3526         return 0;
3527
3528     for (i = 0; i < nb_input_files; i++) {
3529         InputFile *f = input_files[i];
3530
3531         if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
3532             return AVERROR(ENOMEM);
3533
3534         pthread_mutex_init(&f->fifo_lock, NULL);
3535         pthread_cond_init (&f->fifo_cond, NULL);
3536
3537         if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
3538             return AVERROR(ret);
3539     }
3540     return 0;
3541 }
3542
3543 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
3544 {
3545     int ret = 0;
3546
3547     pthread_mutex_lock(&f->fifo_lock);
3548
3549     if (av_fifo_size(f->fifo)) {
3550         av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
3551         pthread_cond_signal(&f->fifo_cond);
3552     } else {
3553         if (f->finished)
3554             ret = AVERROR_EOF;
3555         else
3556             ret = AVERROR(EAGAIN);
3557     }
3558
3559     pthread_mutex_unlock(&f->fifo_lock);
3560
3561     return ret;
3562 }
3563 #endif
3564
3565 static int get_input_packet(InputFile *f, AVPacket *pkt)
3566 {
3567 #if HAVE_PTHREADS
3568     if (nb_input_files > 1)
3569         return get_input_packet_mt(f, pkt);
3570 #endif
3571     return av_read_frame(f->ctx, pkt);
3572 }
3573
3574 /*
3575  * The following code is the main loop of the file converter
3576  */
3577 static int transcode(void)
3578 {
3579     int ret, i;
3580     AVFormatContext *is, *os;
3581     OutputStream *ost;
3582     InputStream *ist;
3583     uint8_t *no_packet;
3584     int no_packet_count = 0;
3585     int64_t timer_start;
3586
3587     if (!(no_packet = av_mallocz(nb_input_files)))
3588         exit_program(1);
3589
3590     ret = transcode_init();
3591     if (ret < 0)
3592         goto fail;
3593
3594     if (stdin_interaction) {
3595         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3596     }
3597
3598     timer_start = av_gettime();
3599
3600 #if HAVE_PTHREADS
3601     if ((ret = init_input_threads()) < 0)
3602         goto fail;
3603 #endif
3604
3605     for (; received_sigterm == 0;) {
3606         int file_index, ist_index;
3607         AVPacket pkt;
3608         int64_t cur_time= av_gettime();
3609
3610         /* if 'q' pressed, exits */
3611         if (stdin_interaction)
3612             if (check_keyboard_interaction(cur_time) < 0)
3613                 break;
3614
3615         /* check if there's any stream where output is still needed */
3616         if (!need_output()) {
3617             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
3618             break;
3619         }
3620
3621         /* select the stream that we must read now */
3622         file_index = select_input_file(no_packet);
3623         /* if none, if is finished */
3624         if (file_index < 0) {
3625             if (no_packet_count) {
3626                 no_packet_count = 0;
3627                 memset(no_packet, 0, nb_input_files);
3628                 av_usleep(10000);
3629                 continue;
3630             }
3631             av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
3632             break;
3633         }
3634
3635         is  = input_files[file_index]->ctx;
3636         ret = get_input_packet(input_files[file_index], &pkt);
3637
3638         if (ret == AVERROR(EAGAIN)) {
3639             no_packet[file_index] = 1;
3640             no_packet_count++;
3641             continue;
3642         }
3643         if (ret < 0) {
3644             if (ret != AVERROR_EOF) {
3645                 print_error(is->filename, ret);
3646                 if (exit_on_error)
3647                     exit_program(1);
3648             }
3649             input_files[file_index]->eof_reached = 1;
3650
3651             for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3652                 ist = input_streams[input_files[file_index]->ist_index + i];
3653                 if (ist->decoding_needed)
3654                     output_packet(ist, NULL);
3655             }
3656
3657             if (opt_shortest)
3658                 break;
3659             else
3660                 continue;
3661         }
3662
3663         no_packet_count = 0;
3664         memset(no_packet, 0, nb_input_files);
3665
3666         if (do_pkt_dump) {
3667             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3668                              is->streams[pkt.stream_index]);
3669         }
3670         /* the following test is needed in case new streams appear
3671            dynamically in stream : we ignore them */
3672         if (pkt.stream_index >= input_files[file_index]->nb_streams)
3673             goto discard_packet;
3674         ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3675         ist = input_streams[ist_index];
3676         if (ist->discard)
3677             goto discard_packet;
3678
3679         if (pkt.dts != AV_NOPTS_VALUE)
3680             pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3681         if (pkt.pts != AV_NOPTS_VALUE)
3682             pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3683
3684         if (pkt.pts != AV_NOPTS_VALUE)
3685             pkt.pts *= ist->ts_scale;
3686         if (pkt.dts != AV_NOPTS_VALUE)
3687             pkt.dts *= ist->ts_scale;
3688
3689         if (debug_ts) {
3690             av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3691                     "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",
3692                     ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3693                     av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3694                     av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3695                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3696                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3697                     input_files[ist->file_index]->ts_offset);
3698         }
3699
3700         if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3701             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3702             int64_t delta   = pkt_dts - ist->next_dts;
3703             if (is->iformat->flags & AVFMT_TS_DISCONT) {
3704             if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3705                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3706                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3707                 pkt_dts+1<ist->pts){
3708                 input_files[ist->file_index]->ts_offset -= delta;
3709                 av_log(NULL, AV_LOG_DEBUG,
3710                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3711                        delta, input_files[ist->file_index]->ts_offset);
3712                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3713                 if (pkt.pts != AV_NOPTS_VALUE)
3714                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3715             }
3716             } else {
3717                 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3718                     (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3719                      pkt_dts+1<ist->pts){
3720                     av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3721                     pkt.dts = AV_NOPTS_VALUE;
3722                 }
3723                 if (pkt.pts != AV_NOPTS_VALUE){
3724                     int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3725                     delta   = pkt_pts - ist->next_dts;
3726                     if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3727                         (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3728                         pkt_pts+1<ist->pts) {
3729                         av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3730                         pkt.pts = AV_NOPTS_VALUE;
3731                     }
3732                 }
3733             }
3734         }
3735
3736         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3737         if ((ret = output_packet(ist, &pkt)) < 0 ||
3738             ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3739             char buf[128];
3740             av_strerror(ret, buf, sizeof(buf));
3741             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
3742                    ist->file_index, ist->st->index, buf);
3743             if (exit_on_error)
3744                 exit_program(1);
3745             av_free_packet(&pkt);
3746             continue;
3747         }
3748
3749     discard_packet:
3750         av_free_packet(&pkt);
3751
3752         /* dump report by using the output first video and audio streams */
3753         print_report(0, timer_start, cur_time);
3754     }
3755 #if HAVE_PTHREADS
3756     free_input_threads();
3757 #endif
3758
3759     /* at the end of stream, we must flush the decoder buffers */
3760     for (i = 0; i < nb_input_streams; i++) {
3761         ist = input_streams[i];
3762         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3763             output_packet(ist, NULL);
3764         }
3765     }
3766     poll_filters();
3767     flush_encoders();
3768
3769     term_exit();
3770
3771     /* write the trailer if needed and close file */
3772     for (i = 0; i < nb_output_files; i++) {
3773         os = output_files[i]->ctx;
3774         av_write_trailer(os);
3775     }
3776
3777     /* dump report by using the first video and audio streams */
3778     print_report(1, timer_start, av_gettime());
3779
3780     /* close each encoder */
3781     for (i = 0; i < nb_output_streams; i++) {
3782         ost = output_streams[i];
3783         if (ost->encoding_needed) {
3784             av_freep(&ost->st->codec->stats_in);
3785             avcodec_close(ost->st->codec);
3786         }
3787     }
3788
3789     /* close each decoder */
3790     for (i = 0; i < nb_input_streams; i++) {
3791         ist = input_streams[i];
3792         if (ist->decoding_needed) {
3793             avcodec_close(ist->st->codec);
3794         }
3795     }
3796
3797     /* finished ! */
3798     ret = 0;
3799
3800  fail:
3801     av_freep(&no_packet);
3802 #if HAVE_PTHREADS
3803     free_input_threads();
3804 #endif
3805
3806     if (output_streams) {
3807         for (i = 0; i < nb_output_streams; i++) {
3808             ost = output_streams[i];
3809             if (ost) {
3810                 if (ost->stream_copy)
3811                     av_freep(&ost->st->codec->extradata);
3812                 if (ost->logfile) {
3813                     fclose(ost->logfile);
3814                     ost->logfile = NULL;
3815                 }
3816                 av_freep(&ost->st->codec->subtitle_header);
3817                 av_free(ost->forced_kf_pts);
3818                 av_dict_free(&ost->opts);
3819             }
3820         }
3821     }
3822     return ret;
3823 }
3824
3825 static int opt_frame_crop(const char *opt, const char *arg)
3826 {
3827     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3828     return AVERROR(EINVAL);
3829 }
3830
3831 static int opt_pad(const char *opt, const char *arg)
3832 {
3833     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3834     return -1;
3835 }
3836
3837 static int opt_video_channel(const char *opt, const char *arg)
3838 {
3839     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3840     return opt_default("channel", arg);
3841 }
3842
3843 static int opt_video_standard(const char *opt, const char *arg)
3844 {
3845     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3846     return opt_default("standard", arg);
3847 }
3848
3849 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3850 {
3851     audio_codec_name = arg;
3852     return parse_option(o, "codec:a", arg, options);
3853 }
3854
3855 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3856 {
3857     video_codec_name = arg;
3858     return parse_option(o, "codec:v", arg, options);
3859 }
3860
3861 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3862 {
3863     subtitle_codec_name = arg;
3864     return parse_option(o, "codec:s", arg, options);
3865 }
3866
3867 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3868 {
3869     return parse_option(o, "codec:d", arg, options);
3870 }
3871
3872 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3873 {
3874     StreamMap *m = NULL;
3875     int i, negative = 0, file_idx;
3876     int sync_file_idx = -1, sync_stream_idx = 0;
3877     char *p, *sync;
3878     char *map;
3879
3880     if (*arg == '-') {
3881         negative = 1;
3882         arg++;
3883     }
3884     map = av_strdup(arg);
3885
3886     /* parse sync stream first, just pick first matching stream */
3887     if (sync = strchr(map, ',')) {
3888         *sync = 0;
3889         sync_file_idx = strtol(sync + 1, &sync, 0);
3890         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3891             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3892             exit_program(1);
3893         }
3894         if (*sync)
3895             sync++;
3896         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3897             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3898                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3899                 sync_stream_idx = i;
3900                 break;
3901             }
3902         if (i == input_files[sync_file_idx]->nb_streams) {
3903             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3904                                        "match any streams.\n", arg);
3905             exit_program(1);
3906         }
3907     }
3908
3909
3910     if (map[0] == '[') {
3911         /* this mapping refers to lavfi output */
3912         const char *c = map + 1;
3913         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3914                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
3915         m = &o->stream_maps[o->nb_stream_maps - 1];
3916         m->linklabel = av_get_token(&c, "]");
3917         if (!m->linklabel) {
3918             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3919             exit_program(1);
3920         }
3921     } else {
3922         file_idx = strtol(map, &p, 0);
3923         if (file_idx >= nb_input_files || file_idx < 0) {
3924             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3925             exit_program(1);
3926         }
3927         if (negative)
3928             /* disable some already defined maps */
3929             for (i = 0; i < o->nb_stream_maps; i++) {
3930                 m = &o->stream_maps[i];
3931                 if (file_idx == m->file_index &&
3932                     check_stream_specifier(input_files[m->file_index]->ctx,
3933                                            input_files[m->file_index]->ctx->streams[m->stream_index],
3934                                            *p == ':' ? p + 1 : p) > 0)
3935                     m->disabled = 1;
3936             }
3937         else
3938             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3939                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3940                             *p == ':' ? p + 1 : p) <= 0)
3941                     continue;
3942                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3943                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
3944                 m = &o->stream_maps[o->nb_stream_maps - 1];
3945
3946                 m->file_index   = file_idx;
3947                 m->stream_index = i;
3948
3949                 if (sync_file_idx >= 0) {
3950                     m->sync_file_index   = sync_file_idx;
3951                     m->sync_stream_index = sync_stream_idx;
3952                 } else {
3953                     m->sync_file_index   = file_idx;
3954                     m->sync_stream_index = i;
3955                 }
3956             }
3957     }
3958
3959     if (!m) {
3960         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3961         exit_program(1);
3962     }
3963
3964     av_freep(&map);
3965     return 0;
3966 }
3967
3968 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3969 {
3970     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3971                                 &o->nb_attachments, o->nb_attachments + 1);
3972     o->attachments[o->nb_attachments - 1] = arg;
3973     return 0;
3974 }
3975
3976 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3977 {
3978     int n;
3979     AVStream *st;
3980     AudioChannelMap *m;
3981
3982     o->audio_channel_maps =
3983         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3984                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3985     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3986
3987     /* muted channel syntax */
3988     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3989     if ((n == 1 || n == 3) && m->channel_idx == -1) {
3990         m->file_idx = m->stream_idx = -1;
3991         if (n == 1)
3992             m->ofile_idx = m->ostream_idx = -1;
3993         return 0;
3994     }
3995
3996     /* normal syntax */
3997     n = sscanf(arg, "%d.%d.%d:%d.%d",
3998                &m->file_idx,  &m->stream_idx, &m->channel_idx,
3999                &m->ofile_idx, &m->ostream_idx);
4000
4001     if (n != 3 && n != 5) {
4002         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
4003                "[file.stream.channel|-1][:syncfile:syncstream]\n");
4004         exit_program(1);
4005     }
4006
4007     if (n != 5) // only file.stream.channel specified
4008         m->ofile_idx = m->ostream_idx = -1;
4009
4010     /* check input */
4011     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
4012         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
4013                m->file_idx);
4014         exit_program(1);
4015     }
4016     if (m->stream_idx < 0 ||
4017         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
4018         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
4019                m->file_idx, m->stream_idx);
4020         exit_program(1);
4021     }
4022     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
4023     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
4024         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
4025                m->file_idx, m->stream_idx);
4026         exit_program(1);
4027     }
4028     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
4029         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
4030                m->file_idx, m->stream_idx, m->channel_idx);
4031         exit_program(1);
4032     }
4033     return 0;
4034 }
4035
4036 /**
4037  * Parse a metadata specifier in arg.
4038  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
4039  * @param index for type c/p, chapter/program index is written here
4040  * @param stream_spec for type s, the stream specifier is written here
4041  */
4042 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
4043 {
4044     if (*arg) {
4045         *type = *arg;
4046         switch (*arg) {
4047         case 'g':
4048             break;
4049         case 's':
4050             if (*(++arg) && *arg != ':') {
4051                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
4052                 exit_program(1);
4053             }
4054             *stream_spec = *arg == ':' ? arg + 1 : "";
4055             break;
4056         case 'c':
4057         case 'p':
4058             if (*(++arg) == ':')
4059                 *index = strtol(++arg, NULL, 0);
4060             break;
4061         default:
4062             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
4063             exit_program(1);
4064         }
4065     } else
4066         *type = 'g';
4067 }
4068
4069 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
4070 {
4071     AVDictionary **meta_in = NULL;
4072     AVDictionary **meta_out = NULL;
4073     int i, ret = 0;
4074     char type_in, type_out;
4075     const char *istream_spec = NULL, *ostream_spec = NULL;
4076     int idx_in = 0, idx_out = 0;
4077
4078     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
4079     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
4080
4081     if (!ic) {
4082         if (type_out == 'g' || !*outspec)
4083             o->metadata_global_manual = 1;
4084         if (type_out == 's' || !*outspec)
4085             o->metadata_streams_manual = 1;
4086         if (type_out == 'c' || !*outspec)
4087             o->metadata_chapters_manual = 1;
4088         return 0;
4089     }
4090
4091     if (type_in == 'g' || type_out == 'g')
4092         o->metadata_global_manual = 1;
4093     if (type_in == 's' || type_out == 's')
4094         o->metadata_streams_manual = 1;
4095     if (type_in == 'c' || type_out == 'c')
4096         o->metadata_chapters_manual = 1;
4097
4098 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4099     if ((index) < 0 || (index) >= (nb_elems)) {\
4100         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4101                 (desc), (index));\
4102         exit_program(1);\
4103     }
4104
4105 #define SET_DICT(type, meta, context, index)\
4106         switch (type) {\
4107         case 'g':\
4108             meta = &context->metadata;\
4109             break;\
4110         case 'c':\
4111             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4112             meta = &context->chapters[index]->metadata;\
4113             break;\
4114         case 'p':\
4115             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4116             meta = &context->programs[index]->metadata;\
4117             break;\
4118         default: av_assert0(0);\
4119         }\
4120
4121     SET_DICT(type_in, meta_in, ic, idx_in);
4122     SET_DICT(type_out, meta_out, oc, idx_out);
4123
4124     /* for input streams choose first matching stream */
4125     if (type_in == 's') {
4126         for (i = 0; i < ic->nb_streams; i++) {
4127             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4128                 meta_in = &ic->streams[i]->metadata;
4129                 break;
4130             } else if (ret < 0)
4131                 exit_program(1);
4132         }
4133         if (!meta_in) {
4134             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
4135             exit_program(1);
4136         }
4137     }
4138
4139     if (type_out == 's') {
4140         for (i = 0; i < oc->nb_streams; i++) {
4141             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4142                 meta_out = &oc->streams[i]->metadata;
4143                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4144             } else if (ret < 0)
4145                 exit_program(1);
4146         }
4147     } else
4148         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4149
4150     return 0;
4151 }
4152
4153 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4154 {
4155     char buf[128];
4156     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4157     struct tm time = *gmtime((time_t*)&recording_timestamp);
4158     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4159     parse_option(o, "metadata", buf, options);
4160
4161     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4162                                  "tag instead.\n", opt);
4163     return 0;
4164 }
4165
4166 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4167 {
4168     const char *codec_string = encoder ? "encoder" : "decoder";
4169     AVCodec *codec;
4170
4171     codec = encoder ?
4172         avcodec_find_encoder_by_name(name) :
4173         avcodec_find_decoder_by_name(name);
4174     if (!codec) {
4175         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4176         exit_program(1);
4177     }
4178     if (codec->type != type) {
4179         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4180         exit_program(1);
4181     }
4182     return codec;
4183 }
4184
4185 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4186 {
4187     char *codec_name = NULL;
4188
4189     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4190     if (codec_name) {
4191         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4192         st->codec->codec_id = codec->id;
4193         return codec;
4194     } else
4195         return avcodec_find_decoder(st->codec->codec_id);
4196 }
4197
4198 /**
4199  * Add all the streams from the given input file to the global
4200  * list of input streams.
4201  */
4202 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4203 {
4204     int i;
4205     char *next, *codec_tag = NULL;
4206
4207     for (i = 0; i < ic->nb_streams; i++) {
4208         AVStream *st = ic->streams[i];
4209         AVCodecContext *dec = st->codec;
4210         InputStream *ist = av_mallocz(sizeof(*ist));
4211         char *framerate = NULL;
4212
4213         if (!ist)
4214             exit_program(1);
4215
4216         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4217         input_streams[nb_input_streams - 1] = ist;
4218
4219         ist->st = st;
4220         ist->file_index = nb_input_files;
4221         ist->discard = 1;
4222         st->discard  = AVDISCARD_ALL;
4223         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
4224
4225         ist->ts_scale = 1.0;
4226         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4227
4228         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4229         if (codec_tag) {
4230             uint32_t tag = strtol(codec_tag, &next, 0);
4231             if (*next)
4232                 tag = AV_RL32(codec_tag);
4233             st->codec->codec_tag = tag;
4234         }
4235
4236         ist->dec = choose_decoder(o, ic, st);
4237
4238         switch (dec->codec_type) {
4239         case AVMEDIA_TYPE_VIDEO:
4240             if(!ist->dec)
4241                 ist->dec = avcodec_find_decoder(dec->codec_id);
4242             if (dec->lowres) {
4243                 dec->flags |= CODEC_FLAG_EMU_EDGE;
4244             }
4245
4246             ist->resample_height  = dec->height;
4247             ist->resample_width   = dec->width;
4248             ist->resample_pix_fmt = dec->pix_fmt;
4249
4250             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
4251             if (framerate && av_parse_video_rate(&ist->framerate,
4252                                                  framerate) < 0) {
4253                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
4254                        framerate);
4255                 exit_program(1);
4256             }
4257
4258             ist->top_field_first = -1;
4259             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
4260
4261             break;
4262         case AVMEDIA_TYPE_AUDIO:
4263             guess_input_channel_layout(ist);
4264
4265             ist->resample_sample_fmt     = dec->sample_fmt;
4266             ist->resample_sample_rate    = dec->sample_rate;
4267             ist->resample_channels       = dec->channels;
4268             ist->resample_channel_layout = dec->channel_layout;
4269
4270             break;
4271         case AVMEDIA_TYPE_DATA:
4272         case AVMEDIA_TYPE_SUBTITLE:
4273             if(!ist->dec)
4274                 ist->dec = avcodec_find_decoder(dec->codec_id);
4275             break;
4276         case AVMEDIA_TYPE_ATTACHMENT:
4277         case AVMEDIA_TYPE_UNKNOWN:
4278             break;
4279         default:
4280             abort();
4281         }
4282     }
4283 }
4284
4285 static void assert_file_overwrite(const char *filename)
4286 {
4287     if ((!file_overwrite || no_file_overwrite) &&
4288         (strchr(filename, ':') == NULL || filename[1] == ':' ||
4289          av_strstart(filename, "file:", NULL))) {
4290         if (avio_check(filename, 0) == 0) {
4291             if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
4292                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4293                 fflush(stderr);
4294                 term_exit();
4295                 signal(SIGINT, SIG_DFL);
4296                 if (!read_yesno()) {
4297                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4298                     exit_program(1);
4299                 }
4300                 term_init();
4301             }
4302             else {
4303                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4304                 exit_program(1);
4305             }
4306         }
4307     }
4308 }
4309
4310 static void dump_attachment(AVStream *st, const char *filename)
4311 {
4312     int ret;
4313     AVIOContext *out = NULL;
4314     AVDictionaryEntry *e;
4315
4316     if (!st->codec->extradata_size) {
4317         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4318                nb_input_files - 1, st->index);
4319         return;
4320     }
4321     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4322         filename = e->value;
4323     if (!*filename) {
4324         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4325                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4326         exit_program(1);
4327     }
4328
4329     assert_file_overwrite(filename);
4330
4331     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4332         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4333                filename);
4334         exit_program(1);
4335     }
4336
4337     avio_write(out, st->codec->extradata, st->codec->extradata_size);
4338     avio_flush(out);
4339     avio_close(out);
4340 }
4341
4342 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4343 {
4344     AVFormatContext *ic;
4345     AVInputFormat *file_iformat = NULL;
4346     int err, i, ret;
4347     int64_t timestamp;
4348     uint8_t buf[128];
4349     AVDictionary **opts;
4350     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
4351
4352     if (o->format) {
4353         if (!(file_iformat = av_find_input_format(o->format))) {
4354             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4355             exit_program(1);
4356         }
4357     }
4358
4359     if (!strcmp(filename, "-"))
4360         filename = "pipe:";
4361
4362     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
4363                          strcmp(filename, "/dev/stdin");
4364
4365     /* get default parameters from command line */
4366     ic = avformat_alloc_context();
4367     if (!ic) {
4368         print_error(filename, AVERROR(ENOMEM));
4369         exit_program(1);
4370     }
4371     if (o->nb_audio_sample_rate) {
4372         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4373         av_dict_set(&format_opts, "sample_rate", buf, 0);
4374     }
4375     if (o->nb_audio_channels) {
4376         /* because we set audio_channels based on both the "ac" and
4377          * "channel_layout" options, we need to check that the specified
4378          * demuxer actually has the "channels" option before setting it */
4379         if (file_iformat && file_iformat->priv_class &&
4380             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4381                         AV_OPT_SEARCH_FAKE_OBJ)) {
4382             snprintf(buf, sizeof(buf), "%d",
4383                      o->audio_channels[o->nb_audio_channels - 1].u.i);
4384             av_dict_set(&format_opts, "channels", buf, 0);
4385         }
4386     }
4387     if (o->nb_frame_rates) {
4388         /* set the format-level framerate option;
4389          * this is important for video grabbers, e.g. x11 */
4390         if (file_iformat && file_iformat->priv_class &&
4391             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
4392                         AV_OPT_SEARCH_FAKE_OBJ)) {
4393             av_dict_set(&format_opts, "framerate",
4394                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4395         }
4396     }
4397     if (o->nb_frame_sizes) {
4398         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4399     }
4400     if (o->nb_frame_pix_fmts)
4401         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4402
4403     ic->video_codec_id   = video_codec_name ?
4404         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
4405     ic->audio_codec_id   = audio_codec_name ?
4406         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
4407     ic->subtitle_codec_id= subtitle_codec_name ?
4408         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4409     ic->flags |= AVFMT_FLAG_NONBLOCK;
4410     ic->interrupt_callback = int_cb;
4411
4412     /* open the input file with generic avformat function */
4413     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4414     if (err < 0) {
4415         print_error(filename, err);
4416         exit_program(1);
4417     }
4418     assert_avoptions(format_opts);
4419
4420     /* apply forced codec ids */
4421     for (i = 0; i < ic->nb_streams; i++)
4422         choose_decoder(o, ic, ic->streams[i]);
4423
4424     /* Set AVCodecContext options for avformat_find_stream_info */
4425     opts = setup_find_stream_info_opts(ic, codec_opts);
4426     orig_nb_streams = ic->nb_streams;
4427
4428     /* If not enough info to get the stream parameters, we decode the
4429        first frames to get it. (used in mpeg case for example) */
4430     ret = avformat_find_stream_info(ic, opts);
4431     if (ret < 0) {
4432         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4433         avformat_close_input(&ic);
4434         exit_program(1);
4435     }
4436
4437     timestamp = o->start_time;
4438     /* add the stream start time */
4439     if (ic->start_time != AV_NOPTS_VALUE)
4440         timestamp += ic->start_time;
4441
4442     /* if seeking requested, we execute it */
4443     if (o->start_time != 0) {
4444         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4445         if (ret < 0) {
4446             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4447                    filename, (double)timestamp / AV_TIME_BASE);
4448         }
4449     }
4450
4451     /* update the current parameters so that they match the one of the input stream */
4452     add_input_streams(o, ic);
4453
4454     /* dump the file content */
4455     av_dump_format(ic, nb_input_files, filename, 0);
4456
4457     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4458     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4459         exit_program(1);
4460
4461     input_files[nb_input_files - 1]->ctx        = ic;
4462     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
4463     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4464     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4465     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
4466
4467     for (i = 0; i < o->nb_dump_attachment; i++) {
4468         int j;
4469
4470         for (j = 0; j < ic->nb_streams; j++) {
4471             AVStream *st = ic->streams[j];
4472
4473             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4474                 dump_attachment(st, o->dump_attachment[i].u.str);
4475         }
4476     }
4477
4478     for (i = 0; i < orig_nb_streams; i++)
4479         av_dict_free(&opts[i]);
4480     av_freep(&opts);
4481
4482     reset_options(o, 1);
4483     return 0;
4484 }
4485
4486 static uint8_t *get_line(AVIOContext *s)
4487 {
4488     AVIOContext *line;
4489     uint8_t *buf;
4490     char c;
4491
4492     if (avio_open_dyn_buf(&line) < 0) {
4493         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4494         exit_program(1);
4495     }
4496
4497     while ((c = avio_r8(s)) && c != '\n')
4498         avio_w8(line, c);
4499     avio_w8(line, 0);
4500     avio_close_dyn_buf(line, &buf);
4501
4502     return buf;
4503 }
4504
4505 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4506 {
4507     int i, ret = 1;
4508     char filename[1000];
4509     const char *base[3] = { getenv("AVCONV_DATADIR"),
4510                             getenv("HOME"),
4511                             AVCONV_DATADIR,
4512                             };
4513
4514     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4515         if (!base[i])
4516             continue;
4517         if (codec_name) {
4518             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4519                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
4520             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4521         }
4522         if (ret) {
4523             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4524                      i != 1 ? "" : "/.avconv", preset_name);
4525             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4526         }
4527     }
4528     return ret;
4529 }
4530
4531 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4532 {
4533     char *codec_name = NULL;
4534
4535     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4536     if (!codec_name) {
4537         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4538                                                   NULL, ost->st->codec->codec_type);
4539         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4540     } else if (!strcmp(codec_name, "copy"))
4541         ost->stream_copy = 1;
4542     else {
4543         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4544         ost->st->codec->codec_id = ost->enc->id;
4545     }
4546 }
4547
4548 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4549 {
4550     OutputStream *ost;
4551     AVStream *st = avformat_new_stream(oc, NULL);
4552     int idx      = oc->nb_streams - 1, ret = 0;
4553     char *bsf = NULL, *next, *codec_tag = NULL;
4554     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4555     double qscale = -1;
4556     char *buf = NULL, *arg = NULL, *preset = NULL;
4557     AVIOContext *s = NULL;
4558
4559     if (!st) {
4560         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4561         exit_program(1);
4562     }
4563
4564     if (oc->nb_streams - 1 < o->nb_streamid_map)
4565         st->id = o->streamid_map[oc->nb_streams - 1];
4566
4567     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4568                                 nb_output_streams + 1);
4569     if (!(ost = av_mallocz(sizeof(*ost))))
4570         exit_program(1);
4571     output_streams[nb_output_streams - 1] = ost;
4572
4573     ost->file_index = nb_output_files;
4574     ost->index      = idx;
4575     ost->st         = st;
4576     st->codec->codec_type = type;
4577     choose_encoder(o, oc, ost);
4578     if (ost->enc) {
4579         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
4580     }
4581
4582     avcodec_get_context_defaults3(st->codec, ost->enc);
4583     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4584
4585     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4586     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4587         do  {
4588             buf = get_line(s);
4589             if (!buf[0] || buf[0] == '#') {
4590                 av_free(buf);
4591                 continue;
4592             }
4593             if (!(arg = strchr(buf, '='))) {
4594                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4595                 exit_program(1);
4596             }
4597             *arg++ = 0;
4598             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4599             av_free(buf);
4600         } while (!s->eof_reached);
4601         avio_close(s);
4602     }
4603     if (ret) {
4604         av_log(NULL, AV_LOG_FATAL,
4605                "Preset %s specified for stream %d:%d, but could not be opened.\n",
4606                preset, ost->file_index, ost->index);
4607         exit_program(1);
4608     }
4609
4610     ost->max_frames = INT64_MAX;
4611     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4612
4613     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4614     while (bsf) {
4615         if (next = strchr(bsf, ','))
4616             *next++ = 0;
4617         if (!(bsfc = av_bitstream_filter_init(bsf))) {
4618             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4619             exit_program(1);
4620         }
4621         if (bsfc_prev)
4622             bsfc_prev->next = bsfc;
4623         else
4624             ost->bitstream_filters = bsfc;
4625
4626         bsfc_prev = bsfc;
4627         bsf       = next;
4628     }
4629
4630     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4631     if (codec_tag) {
4632         uint32_t tag = strtol(codec_tag, &next, 0);
4633         if (*next)
4634             tag = AV_RL32(codec_tag);
4635         st->codec->codec_tag = tag;
4636     }
4637
4638     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4639     if (qscale >= 0 || same_quant) {
4640         st->codec->flags |= CODEC_FLAG_QSCALE;
4641         st->codec->global_quality = FF_QP2LAMBDA * qscale;
4642     }
4643
4644     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4645         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4646
4647     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4648     av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4649     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4650
4651     ost->source_index = source_index;
4652     if (source_index >= 0) {
4653         ost->sync_ist = input_streams[source_index];
4654         input_streams[source_index]->discard = 0;
4655         input_streams[source_index]->st->discard = AVDISCARD_NONE;
4656     }
4657
4658     return ost;
4659 }
4660
4661 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4662 {
4663     int i;
4664     const char *p = str;
4665     for (i = 0;; i++) {
4666         dest[i] = atoi(p);
4667         if (i == 63)
4668             break;
4669         p = strchr(p, ',');
4670         if (!p) {
4671             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4672             exit_program(1);
4673         }
4674         p++;
4675     }
4676 }
4677
4678 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4679 {
4680     AVStream *st;
4681     OutputStream *ost;
4682     AVCodecContext *video_enc;
4683     char *frame_rate = NULL;
4684
4685     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4686     st  = ost->st;
4687     video_enc = st->codec;
4688
4689     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4690     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4691         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4692         exit_program(1);
4693     }
4694
4695     if (!ost->stream_copy) {
4696         const char *p = NULL;
4697         char *frame_size = NULL;
4698         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4699         char *intra_matrix = NULL, *inter_matrix = NULL;
4700         const char *filters = "null";
4701         int i;
4702
4703         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4704         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4705             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4706             exit_program(1);
4707         }
4708
4709         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4710         if (frame_aspect_ratio) {
4711             AVRational q;
4712             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4713                 q.num <= 0 || q.den <= 0) {
4714                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4715                 exit_program(1);
4716             }
4717             ost->frame_aspect_ratio = av_q2d(q);
4718         }
4719
4720         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4721         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4722         if (frame_pix_fmt && *frame_pix_fmt == '+') {
4723             ost->keep_pix_fmt = 1;
4724             if (!*++frame_pix_fmt)
4725                 frame_pix_fmt = NULL;
4726         }
4727         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4728             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4729             exit_program(1);
4730         }
4731         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4732
4733         if (intra_only)
4734             video_enc->gop_size = 0;
4735         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4736         if (intra_matrix) {
4737             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4738                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4739                 exit_program(1);
4740             }
4741             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4742         }
4743         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4744         if (inter_matrix) {
4745             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4746                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4747                 exit_program(1);
4748             }
4749             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4750         }
4751
4752         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4753         for (i = 0; p; i++) {
4754             int start, end, q;
4755             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4756             if (e != 3) {
4757                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4758                 exit_program(1);
4759             }
4760             /* FIXME realloc failure */
4761             video_enc->rc_override =
4762                 av_realloc(video_enc->rc_override,
4763                            sizeof(RcOverride) * (i + 1));
4764             video_enc->rc_override[i].start_frame = start;
4765             video_enc->rc_override[i].end_frame   = end;
4766             if (q > 0) {
4767                 video_enc->rc_override[i].qscale         = q;
4768                 video_enc->rc_override[i].quality_factor = 1.0;
4769             }
4770             else {
4771                 video_enc->rc_override[i].qscale         = 0;
4772                 video_enc->rc_override[i].quality_factor = -q/100.0;
4773             }
4774             p = strchr(p, '/');
4775             if (p) p++;
4776         }
4777         video_enc->rc_override_count = i;
4778         if (!video_enc->rc_initial_buffer_occupancy)
4779             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4780         video_enc->intra_dc_precision = intra_dc_precision - 8;
4781
4782         if (do_psnr)
4783             video_enc->flags|= CODEC_FLAG_PSNR;
4784
4785         /* two pass mode */
4786         if (do_pass) {
4787             if (do_pass & 1) {
4788                 video_enc->flags |= CODEC_FLAG_PASS1;
4789             }
4790             if (do_pass & 2) {
4791                 video_enc->flags |= CODEC_FLAG_PASS2;
4792             }
4793         }
4794
4795         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
4796         if (ost->forced_keyframes)
4797             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
4798
4799         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4800
4801         ost->top_field_first = -1;
4802         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4803
4804         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4805         ost->avfilter = av_strdup(filters);
4806     } else {
4807         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4808     }
4809
4810     return ost;
4811 }
4812
4813 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4814 {
4815     int n;
4816     AVStream *st;
4817     OutputStream *ost;
4818     AVCodecContext *audio_enc;
4819
4820     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4821     st  = ost->st;
4822
4823     audio_enc = st->codec;
4824     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4825
4826     if (!ost->stream_copy) {
4827         char *sample_fmt = NULL;
4828         const char *filters = "anull";
4829
4830         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4831
4832         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4833         if (sample_fmt &&
4834             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4835             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4836             exit_program(1);
4837         }
4838
4839         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4840
4841         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4842
4843         av_assert1(filters);
4844         ost->avfilter = av_strdup(filters);
4845
4846         /* check for channel mapping for this audio stream */
4847         for (n = 0; n < o->nb_audio_channel_maps; n++) {
4848             AudioChannelMap *map = &o->audio_channel_maps[n];
4849             InputStream *ist = input_streams[ost->source_index];
4850             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4851                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
4852                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
4853                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4854                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4855                 else
4856                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4857                            ost->file_index, ost->st->index);
4858             }
4859         }
4860     }
4861
4862     return ost;
4863 }
4864
4865 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4866 {
4867     OutputStream *ost;
4868
4869     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4870     if (!ost->stream_copy) {
4871         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4872         exit_program(1);
4873     }
4874
4875     return ost;
4876 }
4877
4878 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4879 {
4880     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4881     ost->stream_copy = 1;
4882     return ost;
4883 }
4884
4885 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4886 {
4887     AVStream *st;
4888     OutputStream *ost;
4889     AVCodecContext *subtitle_enc;
4890
4891     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4892     st  = ost->st;
4893     subtitle_enc = st->codec;
4894
4895     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4896
4897     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4898
4899     return ost;
4900 }
4901
4902 /* arg format is "output-stream-index:streamid-value". */
4903 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4904 {
4905     int idx;
4906     char *p;
4907     char idx_str[16];
4908
4909     av_strlcpy(idx_str, arg, sizeof(idx_str));
4910     p = strchr(idx_str, ':');
4911     if (!p) {
4912         av_log(NULL, AV_LOG_FATAL,
4913                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4914                arg, opt);
4915         exit_program(1);
4916     }
4917     *p++ = '\0';
4918     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4919     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4920     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4921     return 0;
4922 }
4923
4924 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4925 {
4926     AVFormatContext *is = ifile->ctx;
4927     AVFormatContext *os = ofile->ctx;
4928     int i;
4929
4930     for (i = 0; i < is->nb_chapters; i++) {
4931         AVChapter *in_ch = is->chapters[i], *out_ch;
4932         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
4933                                        AV_TIME_BASE_Q, in_ch->time_base);
4934         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4935                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4936
4937
4938         if (in_ch->end < ts_off)
4939             continue;
4940         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4941             break;
4942
4943         out_ch = av_mallocz(sizeof(AVChapter));
4944         if (!out_ch)
4945             return AVERROR(ENOMEM);
4946
4947         out_ch->id        = in_ch->id;
4948         out_ch->time_base = in_ch->time_base;
4949         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
4950         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
4951
4952         if (copy_metadata)
4953             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4954
4955         os->nb_chapters++;
4956         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4957         if (!os->chapters)
4958             return AVERROR(ENOMEM);
4959         os->chapters[os->nb_chapters - 1] = out_ch;
4960     }
4961     return 0;
4962 }
4963
4964 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4965 {
4966     int i, err;
4967     AVFormatContext *ic = avformat_alloc_context();
4968
4969     ic->interrupt_callback = int_cb;
4970     err = avformat_open_input(&ic, filename, NULL, NULL);
4971     if (err < 0)
4972         return err;
4973     /* copy stream format */
4974     for(i=0;i<ic->nb_streams;i++) {
4975         AVStream *st;
4976         OutputStream *ost;
4977         AVCodec *codec;
4978         AVCodecContext *avctx;
4979
4980         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4981         ost   = new_output_stream(o, s, codec->type, -1);
4982         st    = ost->st;
4983         avctx = st->codec;
4984         ost->enc = codec;
4985
4986         // FIXME: a more elegant solution is needed
4987         memcpy(st, ic->streams[i], sizeof(AVStream));
4988         st->cur_dts = 0;
4989         st->info = av_malloc(sizeof(*st->info));
4990         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4991         st->codec= avctx;
4992         avcodec_copy_context(st->codec, ic->streams[i]->codec);
4993
4994         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4995             choose_sample_fmt(st, codec);
4996         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4997             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4998     }
4999
5000     avformat_close_input(&ic);
5001     return 0;
5002 }
5003
5004 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
5005                                AVFormatContext *oc)
5006 {
5007     OutputStream *ost;
5008
5009     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
5010                                   ofilter->out_tmp->pad_idx)) {
5011     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
5012     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
5013     default:
5014         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
5015                "currently.\n");
5016         exit_program(1);
5017     }
5018
5019     ost->source_index = -1;
5020     ost->filter       = ofilter;
5021
5022     ofilter->ost      = ost;
5023
5024     if (ost->stream_copy) {
5025         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
5026                "which is fed from a complex filtergraph. Filtering and streamcopy "
5027                "cannot be used together.\n", ost->file_index, ost->index);
5028         exit_program(1);
5029     }
5030     if (o->recording_time != INT64_MAX)
5031         av_log(NULL, AV_LOG_WARNING,
5032                "-t does not work with -filter_complex (yet).\n");
5033
5034     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
5035         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
5036         exit_program(1);
5037     }
5038     avfilter_inout_free(&ofilter->out_tmp);
5039 }
5040
5041 static void opt_output_file(void *optctx, const char *filename)
5042 {
5043     OptionsContext *o = optctx;
5044     AVFormatContext *oc;
5045     int i, j, err;
5046     AVOutputFormat *file_oformat;
5047     OutputStream *ost;
5048     InputStream  *ist;
5049
5050     if (configure_complex_filters() < 0) {
5051         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
5052         exit_program(1);
5053     }
5054
5055     if (!strcmp(filename, "-"))
5056         filename = "pipe:";
5057
5058     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
5059     if (!oc) {
5060         print_error(filename, err);
5061         exit_program(1);
5062     }
5063     file_oformat= oc->oformat;
5064     oc->interrupt_callback = int_cb;
5065
5066     /* create streams for all unlabeled output pads */
5067     for (i = 0; i < nb_filtergraphs; i++) {
5068         FilterGraph *fg = filtergraphs[i];
5069         for (j = 0; j < fg->nb_outputs; j++) {
5070             OutputFilter *ofilter = fg->outputs[j];
5071
5072             if (!ofilter->out_tmp || ofilter->out_tmp->name)
5073                 continue;
5074
5075             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
5076                                           ofilter->out_tmp->pad_idx)) {
5077             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
5078             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
5079             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
5080             }
5081             init_output_filter(ofilter, o, oc);
5082         }
5083     }
5084
5085     if (!strcmp(file_oformat->name, "ffm") &&
5086         av_strstart(filename, "http:", NULL)) {
5087         int j;
5088         /* special case for files sent to ffserver: we get the stream
5089            parameters from ffserver */
5090         int err = read_ffserver_streams(o, oc, filename);
5091         if (err < 0) {
5092             print_error(filename, err);
5093             exit_program(1);
5094         }
5095         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
5096             ost = output_streams[j];
5097             for (i = 0; i < nb_input_streams; i++) {
5098                 ist = input_streams[i];
5099                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
5100                     ost->sync_ist= ist;
5101                     ost->source_index= i;
5102                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
5103                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
5104                     ist->discard = 0;
5105                     ist->st->discard = AVDISCARD_NONE;
5106                     break;
5107                 }
5108             }
5109             if(!ost->sync_ist){
5110                 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));
5111                 exit_program(1);
5112             }
5113         }
5114     } else if (!o->nb_stream_maps) {
5115         /* pick the "best" stream of each type */
5116
5117         /* video: highest resolution */
5118         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5119             int area = 0, idx = -1;
5120             for (i = 0; i < nb_input_streams; i++) {
5121                 ist = input_streams[i];
5122                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5123                     ist->st->codec->width * ist->st->codec->height > area) {
5124                     area = ist->st->codec->width * ist->st->codec->height;
5125                     idx = i;
5126                 }
5127             }
5128             if (idx >= 0)
5129                 new_video_stream(o, oc, idx);
5130         }
5131
5132         /* audio: most channels */
5133         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5134             int channels = 0, idx = -1;
5135             for (i = 0; i < nb_input_streams; i++) {
5136                 ist = input_streams[i];
5137                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5138                     ist->st->codec->channels > channels) {
5139                     channels = ist->st->codec->channels;
5140                     idx = i;
5141                 }
5142             }
5143             if (idx >= 0)
5144                 new_audio_stream(o, oc, idx);
5145         }
5146
5147         /* subtitles: pick first */
5148         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5149             for (i = 0; i < nb_input_streams; i++)
5150                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5151                     new_subtitle_stream(o, oc, i);
5152                     break;
5153                 }
5154         }
5155         /* do something with data? */
5156     } else {
5157         for (i = 0; i < o->nb_stream_maps; i++) {
5158             StreamMap *map = &o->stream_maps[i];
5159             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5160
5161             if (map->disabled)
5162                 continue;
5163
5164             if (map->linklabel) {
5165                 FilterGraph *fg;
5166                 OutputFilter *ofilter = NULL;
5167                 int j, k;
5168
5169                 for (j = 0; j < nb_filtergraphs; j++) {
5170                     fg = filtergraphs[j];
5171                     for (k = 0; k < fg->nb_outputs; k++) {
5172                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
5173                         if (out && !strcmp(out->name, map->linklabel)) {
5174                             ofilter = fg->outputs[k];
5175                             goto loop_end;
5176                         }
5177                     }
5178                 }
5179 loop_end:
5180                 if (!ofilter) {
5181                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5182                            "in any defined filter graph.\n", map->linklabel);
5183                     exit_program(1);
5184                 }
5185                 init_output_filter(ofilter, o, oc);
5186             } else {
5187                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5188                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5189                     continue;
5190                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5191                     continue;
5192                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5193                     continue;
5194                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5195                     continue;
5196
5197                 switch (ist->st->codec->codec_type) {
5198                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
5199                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
5200                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
5201                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
5202                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5203                 default:
5204                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5205                            map->file_index, map->stream_index);
5206                     exit_program(1);
5207                 }
5208             }
5209         }
5210     }
5211
5212
5213     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5214         AVDictionaryEntry *e;
5215         ost = output_streams[i];
5216
5217         if (   ost->stream_copy
5218             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5219             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5220             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5221                 exit_program(1);
5222     }
5223
5224     /* handle attached files */
5225     for (i = 0; i < o->nb_attachments; i++) {
5226         AVIOContext *pb;
5227         uint8_t *attachment;
5228         const char *p;
5229         int64_t len;
5230
5231         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5232             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5233                    o->attachments[i]);
5234             exit_program(1);
5235         }
5236         if ((len = avio_size(pb)) <= 0) {
5237             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5238                    o->attachments[i]);
5239             exit_program(1);
5240         }
5241         if (!(attachment = av_malloc(len))) {
5242             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5243                    o->attachments[i]);
5244             exit_program(1);
5245         }
5246         avio_read(pb, attachment, len);
5247
5248         ost = new_attachment_stream(o, oc, -1);
5249         ost->stream_copy               = 0;
5250         ost->attachment_filename       = o->attachments[i];
5251         ost->st->codec->extradata      = attachment;
5252         ost->st->codec->extradata_size = len;
5253
5254         p = strrchr(o->attachments[i], '/');
5255         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5256         avio_close(pb);
5257     }
5258
5259     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5260     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5261         exit_program(1);
5262
5263     output_files[nb_output_files - 1]->ctx            = oc;
5264     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
5265     output_files[nb_output_files - 1]->recording_time = o->recording_time;
5266     if (o->recording_time != INT64_MAX)
5267         oc->duration = o->recording_time;
5268     output_files[nb_output_files - 1]->start_time     = o->start_time;
5269     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5270     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5271
5272     /* check filename in case of an image number is expected */
5273     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5274         if (!av_filename_number_test(oc->filename)) {
5275             print_error(oc->filename, AVERROR(EINVAL));
5276             exit_program(1);
5277         }
5278     }
5279
5280     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5281         /* test if it already exists to avoid losing precious files */
5282         assert_file_overwrite(filename);
5283
5284         /* open the file */
5285         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5286                               &oc->interrupt_callback,
5287                               &output_files[nb_output_files - 1]->opts)) < 0) {
5288             print_error(filename, err);
5289             exit_program(1);
5290         }
5291     }
5292
5293     if (o->mux_preload) {
5294         uint8_t buf[64];
5295         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5296         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5297     }
5298     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5299
5300     /* copy metadata */
5301     for (i = 0; i < o->nb_metadata_map; i++) {
5302         char *p;
5303         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5304
5305         if (in_file_index >= nb_input_files) {
5306             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5307             exit_program(1);
5308         }
5309         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5310     }
5311
5312     /* copy chapters */
5313     if (o->chapters_input_file >= nb_input_files) {
5314         if (o->chapters_input_file == INT_MAX) {
5315             /* copy chapters from the first input file that has them*/
5316             o->chapters_input_file = -1;
5317             for (i = 0; i < nb_input_files; i++)
5318                 if (input_files[i]->ctx->nb_chapters) {
5319                     o->chapters_input_file = i;
5320                     break;
5321                 }
5322         } else {
5323             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5324                    o->chapters_input_file);
5325             exit_program(1);
5326         }
5327     }
5328     if (o->chapters_input_file >= 0)
5329         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5330                       !o->metadata_chapters_manual);
5331
5332     /* copy global metadata by default */
5333     if (!o->metadata_global_manual && nb_input_files){
5334         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5335                      AV_DICT_DONT_OVERWRITE);
5336         if(o->recording_time != INT64_MAX)
5337             av_dict_set(&oc->metadata, "duration", NULL, 0);
5338         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
5339     }
5340     if (!o->metadata_streams_manual)
5341         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5342             InputStream *ist;
5343             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
5344                 continue;
5345             ist = input_streams[output_streams[i]->source_index];
5346             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5347         }
5348
5349     /* process manually set metadata */
5350     for (i = 0; i < o->nb_metadata; i++) {
5351         AVDictionary **m;
5352         char type, *val;
5353         const char *stream_spec;
5354         int index = 0, j, ret = 0;
5355
5356         val = strchr(o->metadata[i].u.str, '=');
5357         if (!val) {
5358             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5359                    o->metadata[i].u.str);
5360             exit_program(1);
5361         }
5362         *val++ = 0;
5363
5364         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5365         if (type == 's') {
5366             for (j = 0; j < oc->nb_streams; j++) {
5367                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5368                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5369                 } else if (ret < 0)
5370                     exit_program(1);
5371             }
5372         }
5373         else {
5374             switch (type) {
5375             case 'g':
5376                 m = &oc->metadata;
5377                 break;
5378             case 'c':
5379                 if (index < 0 || index >= oc->nb_chapters) {
5380                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5381                     exit_program(1);
5382                 }
5383                 m = &oc->chapters[index]->metadata;
5384                 break;
5385             default:
5386                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5387                 exit_program(1);
5388             }
5389             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5390         }
5391     }
5392
5393     reset_options(o, 0);
5394 }
5395
5396 /* same option as mencoder */
5397 static int opt_pass(const char *opt, const char *arg)
5398 {
5399     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5400     return 0;
5401 }
5402
5403 static int64_t getmaxrss(void)
5404 {
5405 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5406     struct rusage rusage;
5407     getrusage(RUSAGE_SELF, &rusage);
5408     return (int64_t)rusage.ru_maxrss * 1024;
5409 #elif HAVE_GETPROCESSMEMORYINFO
5410     HANDLE proc;
5411     PROCESS_MEMORY_COUNTERS memcounters;
5412     proc = GetCurrentProcess();
5413     memcounters.cb = sizeof(memcounters);
5414     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5415     return memcounters.PeakPagefileUsage;
5416 #else
5417     return 0;
5418 #endif
5419 }
5420
5421 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5422 {
5423     return parse_option(o, "q:a", arg, options);
5424 }
5425
5426 static void show_usage(void)
5427 {
5428     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5429     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5430     av_log(NULL, AV_LOG_INFO, "\n");
5431 }
5432
5433 static int opt_help(const char *opt, const char *arg)
5434 {
5435     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5436     av_log_set_callback(log_callback_help);
5437     show_usage();
5438     show_help_options(options, "Main options:\n",
5439                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5440     show_help_options(options, "\nAdvanced options:\n",
5441                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5442                       OPT_EXPERT);
5443     show_help_options(options, "\nVideo options:\n",
5444                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5445                       OPT_VIDEO);
5446     show_help_options(options, "\nAdvanced Video options:\n",
5447                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5448                       OPT_VIDEO | OPT_EXPERT);
5449     show_help_options(options, "\nAudio options:\n",
5450                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5451                       OPT_AUDIO);
5452     show_help_options(options, "\nAdvanced Audio options:\n",
5453                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5454                       OPT_AUDIO | OPT_EXPERT);
5455     show_help_options(options, "\nSubtitle options:\n",
5456                       OPT_SUBTITLE | OPT_GRAB,
5457                       OPT_SUBTITLE);
5458     show_help_options(options, "\nAudio/Video grab options:\n",
5459                       OPT_GRAB,
5460                       OPT_GRAB);
5461     printf("\n");
5462     show_help_children(avcodec_get_class(), flags);
5463     show_help_children(avformat_get_class(), flags);
5464     show_help_children(sws_get_class(), flags);
5465     show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
5466
5467     return 0;
5468 }
5469
5470 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5471 {
5472     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5473     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5474
5475     if (!strncmp(arg, "pal-", 4)) {
5476         norm = PAL;
5477         arg += 4;
5478     } else if (!strncmp(arg, "ntsc-", 5)) {
5479         norm = NTSC;
5480         arg += 5;
5481     } else if (!strncmp(arg, "film-", 5)) {
5482         norm = FILM;
5483         arg += 5;
5484     } else {
5485         /* Try to determine PAL/NTSC by peeking in the input files */
5486         if (nb_input_files) {
5487             int i, j, fr;
5488             for (j = 0; j < nb_input_files; j++) {
5489                 for (i = 0; i < input_files[j]->nb_streams; i++) {
5490                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5491                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5492                         continue;
5493                     fr = c->time_base.den * 1000 / c->time_base.num;
5494                     if (fr == 25000) {
5495                         norm = PAL;
5496                         break;
5497                     } else if ((fr == 29970) || (fr == 23976)) {
5498                         norm = NTSC;
5499                         break;
5500                     }
5501                 }
5502                 if (norm != UNKNOWN)
5503                     break;
5504             }
5505         }
5506         if (norm != UNKNOWN)
5507             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5508     }
5509
5510     if (norm == UNKNOWN) {
5511         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5512         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5513         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5514         exit_program(1);
5515     }
5516
5517     if (!strcmp(arg, "vcd")) {
5518         opt_video_codec(o, "c:v", "mpeg1video");
5519         opt_audio_codec(o, "c:a", "mp2");
5520         parse_option(o, "f", "vcd", options);
5521
5522         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5523         parse_option(o, "r", frame_rates[norm], options);
5524         opt_default("g", norm == PAL ? "15" : "18");
5525
5526         opt_default("b:v", "1150000");
5527         opt_default("maxrate", "1150000");
5528         opt_default("minrate", "1150000");
5529         opt_default("bufsize", "327680"); // 40*1024*8;
5530
5531         opt_default("b:a", "224000");
5532         parse_option(o, "ar", "44100", options);
5533         parse_option(o, "ac", "2", options);
5534
5535         opt_default("packetsize", "2324");
5536         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5537
5538         /* We have to offset the PTS, so that it is consistent with the SCR.
5539            SCR starts at 36000, but the first two packs contain only padding
5540            and the first pack from the other stream, respectively, may also have
5541            been written before.
5542            So the real data starts at SCR 36000+3*1200. */
5543         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5544     } else if (!strcmp(arg, "svcd")) {
5545
5546         opt_video_codec(o, "c:v", "mpeg2video");
5547         opt_audio_codec(o, "c:a", "mp2");
5548         parse_option(o, "f", "svcd", options);
5549
5550         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5551         parse_option(o, "r", frame_rates[norm], options);
5552         parse_option(o, "pix_fmt", "yuv420p", options);
5553         opt_default("g", norm == PAL ? "15" : "18");
5554
5555         opt_default("b:v", "2040000");
5556         opt_default("maxrate", "2516000");
5557         opt_default("minrate", "0"); // 1145000;
5558         opt_default("bufsize", "1835008"); // 224*1024*8;
5559         opt_default("scan_offset", "1");
5560
5561
5562         opt_default("b:a", "224000");
5563         parse_option(o, "ar", "44100", options);
5564
5565         opt_default("packetsize", "2324");
5566
5567     } else if (!strcmp(arg, "dvd")) {
5568
5569         opt_video_codec(o, "c:v", "mpeg2video");
5570         opt_audio_codec(o, "c:a", "ac3");
5571         parse_option(o, "f", "dvd", options);
5572
5573         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5574         parse_option(o, "r", frame_rates[norm], options);
5575         parse_option(o, "pix_fmt", "yuv420p", options);
5576         opt_default("g", norm == PAL ? "15" : "18");
5577
5578         opt_default("b:v", "6000000");
5579         opt_default("maxrate", "9000000");
5580         opt_default("minrate", "0"); // 1500000;
5581         opt_default("bufsize", "1835008"); // 224*1024*8;
5582
5583         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5584         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5585
5586         opt_default("b:a", "448000");
5587         parse_option(o, "ar", "48000", options);
5588
5589     } else if (!strncmp(arg, "dv", 2)) {
5590
5591         parse_option(o, "f", "dv", options);
5592
5593         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5594         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5595                           norm == PAL ? "yuv420p" : "yuv411p", options);
5596         parse_option(o, "r", frame_rates[norm], options);
5597
5598         parse_option(o, "ar", "48000", options);
5599         parse_option(o, "ac", "2", options);
5600
5601     } else {
5602         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5603         return AVERROR(EINVAL);
5604     }
5605     return 0;
5606 }
5607
5608 static int opt_vstats_file(const char *opt, const char *arg)
5609 {
5610     av_free (vstats_filename);
5611     vstats_filename = av_strdup (arg);
5612     return 0;
5613 }
5614
5615 static int opt_vstats(const char *opt, const char *arg)
5616 {
5617     char filename[40];
5618     time_t today2 = time(NULL);
5619     struct tm *today = localtime(&today2);
5620
5621     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5622              today->tm_sec);
5623     return opt_vstats_file(opt, filename);
5624 }
5625
5626 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5627 {
5628     return parse_option(o, "frames:v", arg, options);
5629 }
5630
5631 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5632 {
5633     return parse_option(o, "frames:a", arg, options);
5634 }
5635
5636 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5637 {
5638     return parse_option(o, "frames:d", arg, options);
5639 }
5640
5641 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5642 {
5643     FILE *f=NULL;
5644     char filename[1000], line[1000], tmp_line[1000];
5645     const char *codec_name = *opt == 'v' ? video_codec_name :
5646                              *opt == 'a' ? audio_codec_name :
5647                                            subtitle_codec_name;
5648
5649     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5650         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5651             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5652         }else
5653             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5654         exit_program(1);
5655     }
5656
5657     while (fgets(line, sizeof(line), f)) {
5658         char *key = tmp_line, *value, *endptr;
5659
5660         if (strcspn(line, "#\n\r") == 0)
5661             continue;
5662         strcpy(tmp_line, line);
5663         if (!av_strtok(key,   "=",    &value) ||
5664             !av_strtok(value, "\r\n", &endptr)) {
5665             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5666             exit_program(1);
5667         }
5668         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5669
5670         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
5671         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
5672         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5673         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
5674         else if (opt_default(key, value) < 0) {
5675             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5676                    filename, line, key, value);
5677             exit_program(1);
5678         }
5679     }
5680
5681     fclose(f);
5682
5683     return 0;
5684 }
5685
5686 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5687 {
5688 }
5689
5690 static int opt_passlogfile(const char *opt, const char *arg)
5691 {
5692     pass_logfilename_prefix = arg;
5693 #if CONFIG_LIBX264_ENCODER
5694     return opt_default(opt, arg);
5695 #else
5696     return 0;
5697 #endif
5698 }
5699
5700 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5701 {
5702     char *s = av_asprintf("%s:%c", opt + 1, *opt);
5703     int ret = parse_option(o, s, arg, options);
5704     av_free(s);
5705     return ret;
5706 }
5707
5708 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5709 {
5710     if(!strcmp(opt, "b")){
5711         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5712         return parse_option(o, "b:v", arg, options);
5713     }
5714     return opt_default(opt, arg);
5715 }
5716
5717 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5718 {
5719     char *s;
5720     int ret;
5721     if(!strcmp(opt, "qscale")){
5722         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5723         return parse_option(o, "q:v", arg, options);
5724     }
5725     s = av_asprintf("q%s", opt + 6);
5726     ret = parse_option(o, s, arg, options);
5727     av_free(s);
5728     return ret;
5729 }
5730
5731 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5732 {
5733     if(!strcmp(opt, "profile")){
5734         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5735         return parse_option(o, "profile:v", arg, options);
5736     }
5737     return opt_default(opt, arg);
5738 }
5739
5740 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5741 {
5742     return parse_option(o, "filter:v", arg, options);
5743 }
5744
5745 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5746 {
5747     return parse_option(o, "filter:a", arg, options);
5748 }
5749
5750 static int opt_vsync(const char *opt, const char *arg)
5751 {
5752     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
5753     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
5754     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5755     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
5756
5757     if (video_sync_method == VSYNC_AUTO)
5758         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5759     return 0;
5760 }
5761
5762 static int opt_deinterlace(const char *opt, const char *arg)
5763 {
5764     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5765     do_deinterlace = 1;
5766     return 0;
5767 }
5768
5769 static int opt_timecode(OptionsContext *o, const char *opt, const char *arg)
5770 {
5771     char *tcr = av_asprintf("timecode=%s", arg);
5772     int ret = parse_option(o, "metadata:g", tcr, options);
5773     if (ret >= 0)
5774         ret = opt_default("gop_timecode", arg);
5775     av_free(tcr);
5776     return ret;
5777 }
5778
5779 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5780 {
5781     int idx = locate_option(argc, argv, options, "cpuflags");
5782     if (idx && argv[idx + 1])
5783         opt_cpuflags("cpuflags", argv[idx + 1]);
5784 }
5785
5786 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5787 {
5788     char layout_str[32];
5789     char *stream_str;
5790     char *ac_str;
5791     int ret, channels, ac_str_size;
5792     uint64_t layout;
5793
5794     layout = av_get_channel_layout(arg);
5795     if (!layout) {
5796         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5797         return AVERROR(EINVAL);
5798     }
5799     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5800     ret = opt_default(opt, layout_str);
5801     if (ret < 0)
5802         return ret;
5803
5804     /* set 'ac' option based on channel layout */
5805     channels = av_get_channel_layout_nb_channels(layout);
5806     snprintf(layout_str, sizeof(layout_str), "%d", channels);
5807     stream_str = strchr(opt, ':');
5808     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5809     ac_str = av_mallocz(ac_str_size);
5810     if (!ac_str)
5811         return AVERROR(ENOMEM);
5812     av_strlcpy(ac_str, "ac", 3);
5813     if (stream_str)
5814         av_strlcat(ac_str, stream_str, ac_str_size);
5815     ret = parse_option(o, ac_str, layout_str, options);
5816     av_free(ac_str);
5817
5818     return ret;
5819 }
5820
5821 static int opt_filter_complex(const char *opt, const char *arg)
5822 {
5823     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5824                               &nb_filtergraphs, nb_filtergraphs + 1);
5825     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5826         return AVERROR(ENOMEM);
5827     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
5828     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5829     return 0;
5830 }
5831
5832 static int opt_progress(const char *opt, const char *arg)
5833 {
5834     AVIOContext *avio = NULL;
5835     int ret;
5836
5837     if (!strcmp(arg, "-"))
5838         arg = "pipe:";
5839     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
5840     if (ret < 0) {
5841         av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
5842                arg, av_err2str(ret));
5843         return ret;
5844     }
5845     progress_avio = avio;
5846     return 0;
5847 }
5848
5849 #define OFFSET(x) offsetof(OptionsContext, x)
5850 static const OptionDef options[] = {
5851     /* main options */
5852 #include "cmdutils_common_opts.h"
5853     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5854     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5855     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5856     { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5857     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5858     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5859     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5860     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5861     { "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]" },
5862     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5863       "outfile[,metadata]:infile[,metadata]" },
5864     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
5865     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5866     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5867     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5868     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5869     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5870     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5871     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5872     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5873     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5874       "add timings for benchmarking" },
5875     { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5876       "add timings for each task" },
5877     { "progress", HAS_ARG | OPT_EXPERT, {(void*)opt_progress},
5878       "write program-readable progress information", "url" },
5879     { "stdin", OPT_BOOL | OPT_EXPERT, {(void*)&stdin_interaction},
5880       "enable or disable interaction on standard input" },
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 }