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

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