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

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