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