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