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

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