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

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