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