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

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