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(ist->st->r_frame_rate) >= av_q2d(ist->st->avg_frame_rate)
2992                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(ist->st->time_base)
2993                                && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(icodec->time_base)
2994                                && av_q2d(ist->st->time_base) < 1.0/500 && av_q2d(icodec->time_base) < 1.0/500
2995                      || copy_tb==2){
2996                     codec->time_base.num = ist->st->r_frame_rate.den;
2997                     codec->time_base.den = 2*ist->st->r_frame_rate.num;
2998                     codec->ticks_per_frame = 2;
2999                 } else if (   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
3000                                  && av_q2d(ist->st->time_base) < 1.0/500
3001                     || copy_tb==0){
3002                     codec->time_base = icodec->time_base;
3003                     codec->time_base.num *= icodec->ticks_per_frame;
3004                     codec->time_base.den *= 2;
3005                     codec->ticks_per_frame = 2;
3006                 }
3007             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
3008                       && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
3009                       && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
3010             ) {
3011                 if(   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
3012                                 && av_q2d(ist->st->time_base) < 1.0/500
3013                    || copy_tb==0){
3014                     codec->time_base = icodec->time_base;
3015                     codec->time_base.num *= icodec->ticks_per_frame;
3016                 }
3017             }
3018
3019             if(ost->frame_rate.num)
3020                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3021
3022             av_reduce(&codec->time_base.num, &codec->time_base.den,
3023                         codec->time_base.num, codec->time_base.den, INT_MAX);
3024
3025             switch (codec->codec_type) {
3026             case AVMEDIA_TYPE_AUDIO:
3027                 if (audio_volume != 256) {
3028                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3029                     exit_program(1);
3030                 }
3031                 codec->channel_layout     = icodec->channel_layout;
3032                 codec->sample_rate        = icodec->sample_rate;
3033                 codec->channels           = icodec->channels;
3034                 codec->frame_size         = icodec->frame_size;
3035                 codec->audio_service_type = icodec->audio_service_type;
3036                 codec->block_align        = icodec->block_align;
3037                 if((codec->block_align == 1 || codec->block_align == 1152) && codec->codec_id == CODEC_ID_MP3)
3038                     codec->block_align= 0;
3039                 if(codec->codec_id == CODEC_ID_AC3)
3040                     codec->block_align= 0;
3041                 break;
3042             case AVMEDIA_TYPE_VIDEO:
3043                 codec->pix_fmt            = icodec->pix_fmt;
3044                 codec->width              = icodec->width;
3045                 codec->height             = icodec->height;
3046                 codec->has_b_frames       = icodec->has_b_frames;
3047                 if (!codec->sample_aspect_ratio.num) {
3048                     codec->sample_aspect_ratio   =
3049                     ost->st->sample_aspect_ratio =
3050                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
3051                         ist->st->codec->sample_aspect_ratio.num ?
3052                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3053                 }
3054                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3055                 break;
3056             case AVMEDIA_TYPE_SUBTITLE:
3057                 codec->width  = icodec->width;
3058                 codec->height = icodec->height;
3059                 break;
3060             case AVMEDIA_TYPE_DATA:
3061             case AVMEDIA_TYPE_ATTACHMENT:
3062                 break;
3063             default:
3064                 abort();
3065             }
3066         } else {
3067             if (!ost->enc)
3068                 ost->enc = avcodec_find_encoder(codec->codec_id);
3069             if (!ost->enc) {
3070                 /* should only happen when a default codec is not present. */
3071                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3072                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3073                 ret = AVERROR(EINVAL);
3074                 goto dump_format;
3075             }
3076
3077             if (ist)
3078                 ist->decoding_needed = 1;
3079             ost->encoding_needed = 1;
3080
3081             if (!ost->filter &&
3082                 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3083                  codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
3084                     FilterGraph *fg;
3085                     fg = init_simple_filtergraph(ist, ost);
3086                     if (configure_filtergraph(fg)) {
3087                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3088                         exit(1);
3089                     }
3090             }
3091
3092             if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3093                 if (ost->filter && !ost->frame_rate.num)
3094                     ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3095                 if (ist && !ost->frame_rate.num)
3096                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
3097 //                    ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
3098                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3099                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3100                     ost->frame_rate = ost->enc->supported_framerates[idx];
3101                 }
3102             }
3103
3104             switch (codec->codec_type) {
3105             case AVMEDIA_TYPE_AUDIO:
3106                 codec->sample_fmt     = ost->filter->filter->inputs[0]->format;
3107                 codec->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
3108                 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3109                 codec->channels       = av_get_channel_layout_nb_channels(codec->channel_layout);
3110                 codec->time_base      = (AVRational){ 1, codec->sample_rate };
3111                 break;
3112             case AVMEDIA_TYPE_VIDEO:
3113                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3114                 if (ost->filter && !(codec->time_base.num && codec->time_base.den))
3115                     codec->time_base = ost->filter->filter->inputs[0]->time_base;
3116                 if (   av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3117                    && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3118                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3119                                                "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3120                 }
3121                 for (j = 0; j < ost->forced_kf_count; j++)
3122                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3123                                                          AV_TIME_BASE_Q,
3124                                                          codec->time_base);
3125
3126                 codec->width  = ost->filter->filter->inputs[0]->w;
3127                 codec->height = ost->filter->filter->inputs[0]->h;
3128                 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3129                     ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3130                     av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3131                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
3132                 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3133
3134                 if (!icodec ||
3135                     codec->width   != icodec->width  ||
3136                     codec->height  != icodec->height ||
3137                     codec->pix_fmt != icodec->pix_fmt) {
3138                     codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3139                 }
3140
3141                 if (ost->forced_keyframes)
3142                     parse_forced_key_frames(ost->forced_keyframes, ost,
3143                                             ost->st->codec);
3144                 break;
3145             case AVMEDIA_TYPE_SUBTITLE:
3146                 codec->time_base = (AVRational){1, 1000};
3147                 break;
3148             default:
3149                 abort();
3150                 break;
3151             }
3152             /* two pass mode */
3153             if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3154                 char logfilename[1024];
3155                 FILE *f;
3156
3157                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3158                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3159                          i);
3160                 if (!strcmp(ost->enc->name, "libx264")) {
3161                     av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3162                 } else {
3163                     if (codec->flags & CODEC_FLAG_PASS2) {
3164                         char  *logbuffer;
3165                         size_t logbuffer_size;
3166                         if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3167                             av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3168                                    logfilename);
3169                             exit_program(1);
3170                         }
3171                         codec->stats_in = logbuffer;
3172                     }
3173                     if (codec->flags & CODEC_FLAG_PASS1) {
3174                         f = fopen(logfilename, "wb");
3175                         if (!f) {
3176                             av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3177                                 logfilename, strerror(errno));
3178                             exit_program(1);
3179                         }
3180                         ost->logfile = f;
3181                     }
3182                 }
3183             }
3184         }
3185     }
3186
3187     /* open each encoder */
3188     for (i = 0; i < nb_output_streams; i++) {
3189         ost = output_streams[i];
3190         if (ost->encoding_needed) {
3191             AVCodec      *codec = ost->enc;
3192             AVCodecContext *dec = NULL;
3193
3194             if ((ist = get_input_stream(ost)))
3195                 dec = ist->st->codec;
3196             if (dec && dec->subtitle_header) {
3197                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3198                 if (!ost->st->codec->subtitle_header) {
3199                     ret = AVERROR(ENOMEM);
3200                     goto dump_format;
3201                 }
3202                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3203                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3204             }
3205             if (!av_dict_get(ost->opts, "threads", NULL, 0))
3206                 av_dict_set(&ost->opts, "threads", "auto", 0);
3207             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3208                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3209                         ost->file_index, ost->index);
3210                 ret = AVERROR(EINVAL);
3211                 goto dump_format;
3212             }
3213             if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3214                 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
3215                 av_buffersink_set_frame_size(ost->filter->filter,
3216                                              ost->st->codec->frame_size);
3217             assert_codec_experimental(ost->st->codec, 1);
3218             assert_avoptions(ost->opts);
3219             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3220                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3221                                              " It takes bits/s as argument, not kbits/s\n");
3222             extra_size += ost->st->codec->extradata_size;
3223
3224             if (ost->st->codec->me_threshold)
3225                 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3226         }
3227     }
3228
3229     /* init input streams */
3230     for (i = 0; i < nb_input_streams; i++)
3231         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3232             goto dump_format;
3233
3234     /* discard unused programs */
3235     for (i = 0; i < nb_input_files; i++) {
3236         InputFile *ifile = input_files[i];
3237         for (j = 0; j < ifile->ctx->nb_programs; j++) {
3238             AVProgram *p = ifile->ctx->programs[j];
3239             int discard  = AVDISCARD_ALL;
3240
3241             for (k = 0; k < p->nb_stream_indexes; k++)
3242                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3243                     discard = AVDISCARD_DEFAULT;
3244                     break;
3245                 }
3246             p->discard = discard;
3247         }
3248     }
3249
3250     /* open files and write file headers */
3251     for (i = 0; i < nb_output_files; i++) {
3252         oc = output_files[i]->ctx;
3253         oc->interrupt_callback = int_cb;
3254         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3255             char errbuf[128];
3256             const char *errbuf_ptr = errbuf;
3257             if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
3258                 errbuf_ptr = strerror(AVUNERROR(ret));
3259             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
3260             ret = AVERROR(EINVAL);
3261             goto dump_format;
3262         }
3263 //         assert_avoptions(output_files[i]->opts);
3264         if (strcmp(oc->oformat->name, "rtp")) {
3265             want_sdp = 0;
3266         }
3267     }
3268
3269  dump_format:
3270     /* dump the file output parameters - cannot be done before in case
3271        of stream copy */
3272     for (i = 0; i < nb_output_files; i++) {
3273         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3274     }
3275
3276     /* dump the stream mapping */
3277     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3278     for (i = 0; i < nb_input_streams; i++) {
3279         ist = input_streams[i];
3280
3281         for (j = 0; j < ist->nb_filters; j++) {
3282             if (ist->filters[j]->graph->graph_desc) {
3283                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
3284                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3285                        ist->filters[j]->name);
3286                 if (nb_filtergraphs > 1)
3287                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3288                 av_log(NULL, AV_LOG_INFO, "\n");
3289             }
3290         }
3291     }
3292
3293     for (i = 0; i < nb_output_streams; i++) {
3294         ost = output_streams[i];
3295
3296         if (ost->attachment_filename) {
3297             /* an attached file */
3298             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
3299                    ost->attachment_filename, ost->file_index, ost->index);
3300             continue;
3301         }
3302
3303         if (ost->filter && ost->filter->graph->graph_desc) {
3304             /* output from a complex graph */
3305             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
3306             if (nb_filtergraphs > 1)
3307                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3308
3309             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3310                    ost->index, ost->enc ? ost->enc->name : "?");
3311             continue;
3312         }
3313
3314         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
3315                input_streams[ost->source_index]->file_index,
3316                input_streams[ost->source_index]->st->index,
3317                ost->file_index,
3318                ost->index);
3319         if (ost->sync_ist != input_streams[ost->source_index])
3320             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3321                    ost->sync_ist->file_index,
3322                    ost->sync_ist->st->index);
3323         if (ost->stream_copy)
3324             av_log(NULL, AV_LOG_INFO, " (copy)");
3325         else
3326             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3327                    input_streams[ost->source_index]->dec->name : "?",
3328                    ost->enc ? ost->enc->name : "?");
3329         av_log(NULL, AV_LOG_INFO, "\n");
3330     }
3331
3332     if (ret) {
3333         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3334         return ret;
3335     }
3336
3337     if (want_sdp) {
3338         print_sdp();
3339     }
3340
3341     return 0;
3342 }
3343
3344 /**
3345  * @return 1 if there are still streams where more output is wanted,
3346  *         0 otherwise
3347  */
3348 static int need_output(void)
3349 {
3350     int i;
3351
3352     for (i = 0; i < nb_output_streams; i++) {
3353         OutputStream *ost    = output_streams[i];
3354         OutputFile *of       = output_files[ost->file_index];
3355         AVFormatContext *os  = output_files[ost->file_index]->ctx;
3356
3357         if (ost->is_past_recording_time ||
3358             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3359             continue;
3360         if (ost->frame_number >= ost->max_frames) {
3361             int j;
3362             for (j = 0; j < of->ctx->nb_streams; j++)
3363                 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3364             continue;
3365         }
3366
3367         return 1;
3368     }
3369
3370     return 0;
3371 }
3372
3373 static int input_acceptable(InputStream *ist)
3374 {
3375     av_assert1(!ist->discard);
3376     return !input_files[ist->file_index]->unavailable &&
3377            !input_files[ist->file_index]->eof_reached;
3378 }
3379
3380 static int find_graph_input(FilterGraph *graph)
3381 {
3382     int i, nb_req_max = 0, file_index = -1;
3383
3384     for (i = 0; i < graph->nb_inputs; i++) {
3385         int nb_req = av_buffersrc_get_nb_failed_requests(graph->inputs[i]->filter);
3386         if (nb_req > nb_req_max) {
3387             InputStream *ist = graph->inputs[i]->ist;
3388             if (input_acceptable(ist)) {
3389                 nb_req_max = nb_req;
3390                 file_index = ist->file_index;
3391             }
3392         }
3393     }
3394
3395     return file_index;
3396 }
3397
3398 /**
3399  * Select the input file to read from.
3400  *
3401  * @return  >=0 index of the input file to use;
3402  *          -1  if no file is acceptable;
3403  *          -2  to read from filters without reading from a file
3404  */
3405 static int select_input_file(void)
3406 {
3407     int i, ret, nb_active_out = nb_output_streams, ost_index = -1;
3408     int64_t opts_min;
3409     OutputStream *ost;
3410     AVFilterBufferRef *dummy;
3411
3412     for (i = 0; i < nb_output_streams; i++)
3413         nb_active_out -= output_streams[i]->unavailable =
3414             output_streams[i]->is_past_recording_time;
3415     while (nb_active_out) {
3416         opts_min = INT64_MAX;
3417         ost_index = -1;
3418         for (i = 0; i < nb_output_streams; i++) {
3419             OutputStream *ost = output_streams[i];
3420             int64_t opts = av_rescale_q(ost->st->cur_dts, ost->st->time_base,
3421                                         AV_TIME_BASE_Q);
3422             if (!ost->unavailable && opts < opts_min) {
3423                 opts_min  = opts;
3424                 ost_index = i;
3425             }
3426         }
3427         if (ost_index < 0)
3428             return -1;
3429
3430         ost = output_streams[ost_index];
3431         if (ost->source_index >= 0) {
3432             /* ost is directly connected to an input */
3433             InputStream *ist = input_streams[ost->source_index];
3434             if (input_acceptable(ist))
3435                 return ist->file_index;
3436         } else {
3437             /* ost is connected to a complex filtergraph */
3438             av_assert1(ost->filter);
3439             ret = av_buffersink_get_buffer_ref(ost->filter->filter, &dummy,
3440                                                AV_BUFFERSINK_FLAG_PEEK);
3441             if (ret >= 0)
3442                 return -2;
3443             ret = find_graph_input(ost->filter->graph);
3444             if (ret >= 0)
3445                 return ret;
3446         }
3447         ost->unavailable = 1;
3448         nb_active_out--;
3449     }
3450     return -1;
3451 }
3452
3453 static int check_keyboard_interaction(int64_t cur_time)
3454 {
3455     int i, ret, key;
3456     static int64_t last_time;
3457     if (received_nb_signals)
3458         return AVERROR_EXIT;
3459     /* read_key() returns 0 on EOF */
3460     if(cur_time - last_time >= 100000 && !run_as_daemon){
3461         key =  read_key();
3462         last_time = cur_time;
3463     }else
3464         key = -1;
3465     if (key == 'q')
3466         return AVERROR_EXIT;
3467     if (key == '+') av_log_set_level(av_log_get_level()+10);
3468     if (key == '-') av_log_set_level(av_log_get_level()-10);
3469     if (key == 's') qp_hist     ^= 1;
3470     if (key == 'h'){
3471         if (do_hex_dump){
3472             do_hex_dump = do_pkt_dump = 0;
3473         } else if(do_pkt_dump){
3474             do_hex_dump = 1;
3475         } else
3476             do_pkt_dump = 1;
3477         av_log_set_level(AV_LOG_DEBUG);
3478     }
3479     if (key == 'c' || key == 'C'){
3480         char buf[4096], target[64], command[256], arg[256] = {0};
3481         double time;
3482         int k, n = 0;
3483         fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3484         i = 0;
3485         while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3486             if (k > 0)
3487                 buf[i++] = k;
3488         buf[i] = 0;
3489         if (k > 0 &&
3490             (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3491             av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3492                    target, time, command, arg);
3493             for (i = 0; i < nb_filtergraphs; i++) {
3494                 FilterGraph *fg = filtergraphs[i];
3495                 if (fg->graph) {
3496                     if (time < 0) {
3497                         ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3498                                                           key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3499                         fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3500                     } else {
3501                         ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3502                     }
3503                 }
3504             }
3505         } else {
3506             av_log(NULL, AV_LOG_ERROR,
3507                    "Parse error, at least 3 arguments were expected, "
3508                    "only %d given in string '%s'\n", n, buf);
3509         }
3510     }
3511     if (key == 'd' || key == 'D'){
3512         int debug=0;
3513         if(key == 'D') {
3514             debug = input_streams[0]->st->codec->debug<<1;
3515             if(!debug) debug = 1;
3516             while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3517                 debug += debug;
3518         }else
3519             if(scanf("%d", &debug)!=1)
3520                 fprintf(stderr,"error parsing debug value\n");
3521         for(i=0;i<nb_input_streams;i++) {
3522             input_streams[i]->st->codec->debug = debug;
3523         }
3524         for(i=0;i<nb_output_streams;i++) {
3525             OutputStream *ost = output_streams[i];
3526             ost->st->codec->debug = debug;
3527         }
3528         if(debug) av_log_set_level(AV_LOG_DEBUG);
3529         fprintf(stderr,"debug=%d\n", debug);
3530     }
3531     if (key == '?'){
3532         fprintf(stderr, "key    function\n"
3533                         "?      show this help\n"
3534                         "+      increase verbosity\n"
3535                         "-      decrease verbosity\n"
3536                         "c      Send command to filtergraph\n"
3537                         "D      cycle through available debug modes\n"
3538                         "h      dump packets/hex press to cycle through the 3 states\n"
3539                         "q      quit\n"
3540                         "s      Show QP histogram\n"
3541         );
3542     }
3543     return 0;
3544 }
3545
3546 #if HAVE_PTHREADS
3547 static void *input_thread(void *arg)
3548 {
3549     InputFile *f = arg;
3550     int ret = 0;
3551
3552     while (!transcoding_finished && ret >= 0) {
3553         AVPacket pkt;
3554         ret = av_read_frame(f->ctx, &pkt);
3555
3556         if (ret == AVERROR(EAGAIN)) {
3557             av_usleep(10000);
3558             ret = 0;
3559             continue;
3560         } else if (ret < 0)
3561             break;
3562
3563         pthread_mutex_lock(&f->fifo_lock);
3564         while (!av_fifo_space(f->fifo))
3565             pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
3566
3567         av_dup_packet(&pkt);
3568         av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
3569
3570         pthread_mutex_unlock(&f->fifo_lock);
3571     }
3572
3573     f->finished = 1;
3574     return NULL;
3575 }
3576
3577 static void free_input_threads(void)
3578 {
3579     int i;
3580
3581     if (nb_input_files == 1)
3582         return;
3583
3584     transcoding_finished = 1;
3585
3586     for (i = 0; i < nb_input_files; i++) {
3587         InputFile *f = input_files[i];
3588         AVPacket pkt;
3589
3590         if (!f->fifo || f->joined)
3591             continue;
3592
3593         pthread_mutex_lock(&f->fifo_lock);
3594         while (av_fifo_size(f->fifo)) {
3595             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3596             av_free_packet(&pkt);
3597         }
3598         pthread_cond_signal(&f->fifo_cond);
3599         pthread_mutex_unlock(&f->fifo_lock);
3600
3601         pthread_join(f->thread, NULL);
3602         f->joined = 1;
3603
3604         while (av_fifo_size(f->fifo)) {
3605             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3606             av_free_packet(&pkt);
3607         }
3608         av_fifo_free(f->fifo);
3609     }
3610 }
3611
3612 static int init_input_threads(void)
3613 {
3614     int i, ret;
3615
3616     if (nb_input_files == 1)
3617         return 0;
3618
3619     for (i = 0; i < nb_input_files; i++) {
3620         InputFile *f = input_files[i];
3621
3622         if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
3623             return AVERROR(ENOMEM);
3624
3625         pthread_mutex_init(&f->fifo_lock, NULL);
3626         pthread_cond_init (&f->fifo_cond, NULL);
3627
3628         if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
3629             return AVERROR(ret);
3630     }
3631     return 0;
3632 }
3633
3634 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
3635 {
3636     int ret = 0;
3637
3638     pthread_mutex_lock(&f->fifo_lock);
3639
3640     if (av_fifo_size(f->fifo)) {
3641         av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
3642         pthread_cond_signal(&f->fifo_cond);
3643     } else {
3644         if (f->finished)
3645             ret = AVERROR_EOF;
3646         else
3647             ret = AVERROR(EAGAIN);
3648     }
3649
3650     pthread_mutex_unlock(&f->fifo_lock);
3651
3652     return ret;
3653 }
3654 #endif
3655
3656 static int get_input_packet(InputFile *f, AVPacket *pkt)
3657 {
3658 #if HAVE_PTHREADS
3659     if (nb_input_files > 1)
3660         return get_input_packet_mt(f, pkt);
3661 #endif
3662     return av_read_frame(f->ctx, pkt);
3663 }
3664
3665 /*
3666  * The following code is the main loop of the file converter
3667  */
3668 static int transcode(void)
3669 {
3670     int ret, i;
3671     AVFormatContext *is, *os;
3672     OutputStream *ost;
3673     InputStream *ist;
3674     int no_packet_count = 0;
3675     int64_t timer_start;
3676
3677     ret = transcode_init();
3678     if (ret < 0)
3679         goto fail;
3680
3681     if (stdin_interaction) {
3682         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3683     }
3684
3685     timer_start = av_gettime();
3686
3687 #if HAVE_PTHREADS
3688     if ((ret = init_input_threads()) < 0)
3689         goto fail;
3690 #endif
3691
3692     for (; received_sigterm == 0;) {
3693         int file_index, ist_index;
3694         AVPacket pkt;
3695         int64_t cur_time= av_gettime();
3696
3697         /* if 'q' pressed, exits */
3698         if (stdin_interaction)
3699             if (check_keyboard_interaction(cur_time) < 0)
3700                 break;
3701
3702         /* check if there's any stream where output is still needed */
3703         if (!need_output()) {
3704             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
3705             break;
3706         }
3707
3708         /* select the stream that we must read now */
3709         file_index = select_input_file();
3710         /* if none, if is finished */
3711         if (file_index == -2) {
3712             poll_filters() ;
3713             continue;
3714         }
3715         if (file_index < 0) {
3716             if (no_packet_count) {
3717                 no_packet_count = 0;
3718                 for (i = 0; i < nb_input_files; i++)
3719                     input_files[i]->unavailable = 0;
3720                 av_usleep(10000);
3721                 continue;
3722             }
3723             av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
3724             break;
3725         }
3726
3727         is  = input_files[file_index]->ctx;
3728         ret = get_input_packet(input_files[file_index], &pkt);
3729
3730         if (ret == AVERROR(EAGAIN)) {
3731             input_files[file_index]->unavailable = 1;
3732             no_packet_count++;
3733             continue;
3734         }
3735         if (ret < 0) {
3736             if (ret != AVERROR_EOF) {
3737                 print_error(is->filename, ret);
3738                 if (exit_on_error)
3739                     exit_program(1);
3740             }
3741             input_files[file_index]->eof_reached = 1;
3742
3743             for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3744                 ist = input_streams[input_files[file_index]->ist_index + i];
3745                 if (ist->decoding_needed)
3746                     output_packet(ist, NULL);
3747                 poll_filters();
3748             }
3749
3750             if (opt_shortest)
3751                 break;
3752             else
3753                 continue;
3754         }
3755
3756         no_packet_count = 0;
3757         for (i = 0; i < nb_input_files; i++)
3758             input_files[i]->unavailable = 0;
3759
3760         if (do_pkt_dump) {
3761             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3762                              is->streams[pkt.stream_index]);
3763         }
3764         /* the following test is needed in case new streams appear
3765            dynamically in stream : we ignore them */
3766         if (pkt.stream_index >= input_files[file_index]->nb_streams) {
3767             report_new_stream(file_index, &pkt);
3768             goto discard_packet;
3769         }
3770         ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3771         ist = input_streams[ist_index];
3772         if (ist->discard)
3773             goto discard_packet;
3774
3775         if(!ist->wrap_correction_done && input_files[file_index]->ctx->start_time != AV_NOPTS_VALUE && ist->st->pts_wrap_bits < 64){
3776             uint64_t stime = av_rescale_q(input_files[file_index]->ctx->start_time, AV_TIME_BASE_Q, ist->st->time_base);
3777             uint64_t stime2= stime + (1LL<<ist->st->pts_wrap_bits);
3778             ist->wrap_correction_done = 1;
3779             if(pkt.dts != AV_NOPTS_VALUE && pkt.dts > stime && pkt.dts - stime > stime2 - pkt.dts) {
3780                 pkt.dts -= 1LL<<ist->st->pts_wrap_bits;
3781                 ist->wrap_correction_done = 0;
3782             }
3783             if(pkt.pts != AV_NOPTS_VALUE && pkt.pts > stime && pkt.pts - stime > stime2 - pkt.pts) {
3784                 pkt.pts -= 1LL<<ist->st->pts_wrap_bits;
3785                 ist->wrap_correction_done = 0;
3786             }
3787         }
3788
3789         if (pkt.dts != AV_NOPTS_VALUE)
3790             pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3791         if (pkt.pts != AV_NOPTS_VALUE)
3792             pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3793
3794         if (pkt.pts != AV_NOPTS_VALUE)
3795             pkt.pts *= ist->ts_scale;
3796         if (pkt.dts != AV_NOPTS_VALUE)
3797             pkt.dts *= ist->ts_scale;
3798
3799         if (debug_ts) {
3800             av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3801                     "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",
3802                     ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3803                     av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &AV_TIME_BASE_Q),
3804                     av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &AV_TIME_BASE_Q),
3805                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3806                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3807                     input_files[ist->file_index]->ts_offset);
3808         }
3809
3810         if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3811             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3812             int64_t delta   = pkt_dts - ist->next_dts;
3813             if (is->iformat->flags & AVFMT_TS_DISCONT) {
3814             if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3815                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3816                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3817                 pkt_dts+1<ist->pts){
3818                 input_files[ist->file_index]->ts_offset -= delta;
3819                 av_log(NULL, AV_LOG_DEBUG,
3820                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3821                        delta, input_files[ist->file_index]->ts_offset);
3822                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3823                 if (pkt.pts != AV_NOPTS_VALUE)
3824                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3825             }
3826             } else {
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_dts+1<ist->pts){
3830                     av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3831                     pkt.dts = AV_NOPTS_VALUE;
3832                 }
3833                 if (pkt.pts != AV_NOPTS_VALUE){
3834                     int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3835                     delta   = pkt_pts - ist->next_dts;
3836                     if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3837                         (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3838                         pkt_pts+1<ist->pts) {
3839                         av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3840                         pkt.pts = AV_NOPTS_VALUE;
3841                     }
3842                 }
3843             }
3844         }
3845
3846         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3847         if ((ret = output_packet(ist, &pkt)) < 0 ||
3848             ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3849             char buf[128];
3850             av_strerror(ret, buf, sizeof(buf));
3851             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
3852                    ist->file_index, ist->st->index, buf);
3853             if (exit_on_error)
3854                 exit_program(1);
3855             av_free_packet(&pkt);
3856             continue;
3857         }
3858
3859     discard_packet:
3860         av_free_packet(&pkt);
3861
3862         /* dump report by using the output first video and audio streams */
3863         print_report(0, timer_start, cur_time);
3864     }
3865 #if HAVE_PTHREADS
3866     free_input_threads();
3867 #endif
3868
3869     /* at the end of stream, we must flush the decoder buffers */
3870     for (i = 0; i < nb_input_streams; i++) {
3871         ist = input_streams[i];
3872         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3873             output_packet(ist, NULL);
3874         }
3875     }
3876     poll_filters();
3877     flush_encoders();
3878
3879     term_exit();
3880
3881     /* write the trailer if needed and close file */
3882     for (i = 0; i < nb_output_files; i++) {
3883         os = output_files[i]->ctx;
3884         av_write_trailer(os);
3885     }
3886
3887     /* dump report by using the first video and audio streams */
3888     print_report(1, timer_start, av_gettime());
3889
3890     /* close each encoder */
3891     for (i = 0; i < nb_output_streams; i++) {
3892         ost = output_streams[i];
3893         if (ost->encoding_needed) {
3894             av_freep(&ost->st->codec->stats_in);
3895             avcodec_close(ost->st->codec);
3896         }
3897     }
3898
3899     /* close each decoder */
3900     for (i = 0; i < nb_input_streams; i++) {
3901         ist = input_streams[i];
3902         if (ist->decoding_needed) {
3903             avcodec_close(ist->st->codec);
3904         }
3905     }
3906
3907     /* finished ! */
3908     ret = 0;
3909
3910  fail:
3911 #if HAVE_PTHREADS
3912     free_input_threads();
3913 #endif
3914
3915     if (output_streams) {
3916         for (i = 0; i < nb_output_streams; i++) {
3917             ost = output_streams[i];
3918             if (ost) {
3919                 if (ost->stream_copy)
3920                     av_freep(&ost->st->codec->extradata);
3921                 if (ost->logfile) {
3922                     fclose(ost->logfile);
3923                     ost->logfile = NULL;
3924                 }
3925                 av_freep(&ost->st->codec->subtitle_header);
3926                 av_free(ost->forced_kf_pts);
3927                 av_dict_free(&ost->opts);
3928             }
3929         }
3930     }
3931     return ret;
3932 }
3933
3934 static int opt_frame_crop(const char *opt, const char *arg)
3935 {
3936     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3937     return AVERROR(EINVAL);
3938 }
3939
3940 static int opt_pad(const char *opt, const char *arg)
3941 {
3942     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3943     return -1;
3944 }
3945
3946 static int opt_video_channel(const char *opt, const char *arg)
3947 {
3948     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3949     return opt_default("channel", arg);
3950 }
3951
3952 static int opt_video_standard(const char *opt, const char *arg)
3953 {
3954     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3955     return opt_default("standard", arg);
3956 }
3957
3958 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3959 {
3960     audio_codec_name = arg;
3961     return parse_option(o, "codec:a", arg, options);
3962 }
3963
3964 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3965 {
3966     video_codec_name = arg;
3967     return parse_option(o, "codec:v", arg, options);
3968 }
3969
3970 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3971 {
3972     subtitle_codec_name = arg;
3973     return parse_option(o, "codec:s", arg, options);
3974 }
3975
3976 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3977 {
3978     return parse_option(o, "codec:d", arg, options);
3979 }
3980
3981 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3982 {
3983     StreamMap *m = NULL;
3984     int i, negative = 0, file_idx;
3985     int sync_file_idx = -1, sync_stream_idx = 0;
3986     char *p, *sync;
3987     char *map;
3988
3989     if (*arg == '-') {
3990         negative = 1;
3991         arg++;
3992     }
3993     map = av_strdup(arg);
3994
3995     /* parse sync stream first, just pick first matching stream */
3996     if (sync = strchr(map, ',')) {
3997         *sync = 0;
3998         sync_file_idx = strtol(sync + 1, &sync, 0);
3999         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
4000             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
4001             exit_program(1);
4002         }
4003         if (*sync)
4004             sync++;
4005         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
4006             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
4007                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
4008                 sync_stream_idx = i;
4009                 break;
4010             }
4011         if (i == input_files[sync_file_idx]->nb_streams) {
4012             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
4013                                        "match any streams.\n", arg);
4014             exit_program(1);
4015         }
4016     }
4017
4018
4019     if (map[0] == '[') {
4020         /* this mapping refers to lavfi output */
4021         const char *c = map + 1;
4022         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
4023                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
4024         m = &o->stream_maps[o->nb_stream_maps - 1];
4025         m->linklabel = av_get_token(&c, "]");
4026         if (!m->linklabel) {
4027             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
4028             exit_program(1);
4029         }
4030     } else {
4031         file_idx = strtol(map, &p, 0);
4032         if (file_idx >= nb_input_files || file_idx < 0) {
4033             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
4034             exit_program(1);
4035         }
4036         if (negative)
4037             /* disable some already defined maps */
4038             for (i = 0; i < o->nb_stream_maps; i++) {
4039                 m = &o->stream_maps[i];
4040                 if (file_idx == m->file_index &&
4041                     check_stream_specifier(input_files[m->file_index]->ctx,
4042                                            input_files[m->file_index]->ctx->streams[m->stream_index],
4043                                            *p == ':' ? p + 1 : p) > 0)
4044                     m->disabled = 1;
4045             }
4046         else
4047             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
4048                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
4049                             *p == ':' ? p + 1 : p) <= 0)
4050                     continue;
4051                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
4052                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
4053                 m = &o->stream_maps[o->nb_stream_maps - 1];
4054
4055                 m->file_index   = file_idx;
4056                 m->stream_index = i;
4057
4058                 if (sync_file_idx >= 0) {
4059                     m->sync_file_index   = sync_file_idx;
4060                     m->sync_stream_index = sync_stream_idx;
4061                 } else {
4062                     m->sync_file_index   = file_idx;
4063                     m->sync_stream_index = i;
4064                 }
4065             }
4066     }
4067
4068     if (!m) {
4069         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
4070         exit_program(1);
4071     }
4072
4073     av_freep(&map);
4074     return 0;
4075 }
4076
4077 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
4078 {
4079     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
4080                                 &o->nb_attachments, o->nb_attachments + 1);
4081     o->attachments[o->nb_attachments - 1] = arg;
4082     return 0;
4083 }
4084
4085 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
4086 {
4087     int n;
4088     AVStream *st;
4089     AudioChannelMap *m;
4090
4091     o->audio_channel_maps =
4092         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
4093                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
4094     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
4095
4096     /* muted channel syntax */
4097     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
4098     if ((n == 1 || n == 3) && m->channel_idx == -1) {
4099         m->file_idx = m->stream_idx = -1;
4100         if (n == 1)
4101             m->ofile_idx = m->ostream_idx = -1;
4102         return 0;
4103     }
4104
4105     /* normal syntax */
4106     n = sscanf(arg, "%d.%d.%d:%d.%d",
4107                &m->file_idx,  &m->stream_idx, &m->channel_idx,
4108                &m->ofile_idx, &m->ostream_idx);
4109
4110     if (n != 3 && n != 5) {
4111         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
4112                "[file.stream.channel|-1][:syncfile:syncstream]\n");
4113         exit_program(1);
4114     }
4115
4116     if (n != 5) // only file.stream.channel specified
4117         m->ofile_idx = m->ostream_idx = -1;
4118
4119     /* check input */
4120     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
4121         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
4122                m->file_idx);
4123         exit_program(1);
4124     }
4125     if (m->stream_idx < 0 ||
4126         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
4127         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
4128                m->file_idx, m->stream_idx);
4129         exit_program(1);
4130     }
4131     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
4132     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
4133         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
4134                m->file_idx, m->stream_idx);
4135         exit_program(1);
4136     }
4137     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
4138         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
4139                m->file_idx, m->stream_idx, m->channel_idx);
4140         exit_program(1);
4141     }
4142     return 0;
4143 }
4144
4145 /**
4146  * Parse a metadata specifier in arg.
4147  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
4148  * @param index for type c/p, chapter/program index is written here
4149  * @param stream_spec for type s, the stream specifier is written here
4150  */
4151 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
4152 {
4153     if (*arg) {
4154         *type = *arg;
4155         switch (*arg) {
4156         case 'g':
4157             break;
4158         case 's':
4159             if (*(++arg) && *arg != ':') {
4160                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
4161                 exit_program(1);
4162             }
4163             *stream_spec = *arg == ':' ? arg + 1 : "";
4164             break;
4165         case 'c':
4166         case 'p':
4167             if (*(++arg) == ':')
4168                 *index = strtol(++arg, NULL, 0);
4169             break;
4170         default:
4171             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
4172             exit_program(1);
4173         }
4174     } else
4175         *type = 'g';
4176 }
4177
4178 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
4179 {
4180     AVDictionary **meta_in = NULL;
4181     AVDictionary **meta_out = NULL;
4182     int i, ret = 0;
4183     char type_in, type_out;
4184     const char *istream_spec = NULL, *ostream_spec = NULL;
4185     int idx_in = 0, idx_out = 0;
4186
4187     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
4188     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
4189
4190     if (!ic) {
4191         if (type_out == 'g' || !*outspec)
4192             o->metadata_global_manual = 1;
4193         if (type_out == 's' || !*outspec)
4194             o->metadata_streams_manual = 1;
4195         if (type_out == 'c' || !*outspec)
4196             o->metadata_chapters_manual = 1;
4197         return 0;
4198     }
4199
4200     if (type_in == 'g' || type_out == 'g')
4201         o->metadata_global_manual = 1;
4202     if (type_in == 's' || type_out == 's')
4203         o->metadata_streams_manual = 1;
4204     if (type_in == 'c' || type_out == 'c')
4205         o->metadata_chapters_manual = 1;
4206
4207 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4208     if ((index) < 0 || (index) >= (nb_elems)) {\
4209         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4210                 (desc), (index));\
4211         exit_program(1);\
4212     }
4213
4214 #define SET_DICT(type, meta, context, index)\
4215         switch (type) {\
4216         case 'g':\
4217             meta = &context->metadata;\
4218             break;\
4219         case 'c':\
4220             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4221             meta = &context->chapters[index]->metadata;\
4222             break;\
4223         case 'p':\
4224             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4225             meta = &context->programs[index]->metadata;\
4226             break;\
4227         default: av_assert0(0);\
4228         }\
4229
4230     SET_DICT(type_in, meta_in, ic, idx_in);
4231     SET_DICT(type_out, meta_out, oc, idx_out);
4232
4233     /* for input streams choose first matching stream */
4234     if (type_in == 's') {
4235         for (i = 0; i < ic->nb_streams; i++) {
4236             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4237                 meta_in = &ic->streams[i]->metadata;
4238                 break;
4239             } else if (ret < 0)
4240                 exit_program(1);
4241         }
4242         if (!meta_in) {
4243             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
4244             exit_program(1);
4245         }
4246     }
4247
4248     if (type_out == 's') {
4249         for (i = 0; i < oc->nb_streams; i++) {
4250             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4251                 meta_out = &oc->streams[i]->metadata;
4252                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4253             } else if (ret < 0)
4254                 exit_program(1);
4255         }
4256     } else
4257         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4258
4259     return 0;
4260 }
4261
4262 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4263 {
4264     char buf[128];
4265     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4266     struct tm time = *gmtime((time_t*)&recording_timestamp);
4267     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4268     parse_option(o, "metadata", buf, options);
4269
4270     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4271                                  "tag instead.\n", opt);
4272     return 0;
4273 }
4274
4275 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4276 {
4277     const char *codec_string = encoder ? "encoder" : "decoder";
4278     AVCodec *codec;
4279
4280     codec = encoder ?
4281         avcodec_find_encoder_by_name(name) :
4282         avcodec_find_decoder_by_name(name);
4283     if (!codec) {
4284         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4285         exit_program(1);
4286     }
4287     if (codec->type != type) {
4288         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4289         exit_program(1);
4290     }
4291     return codec;
4292 }
4293
4294 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4295 {
4296     char *codec_name = NULL;
4297
4298     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4299     if (codec_name) {
4300         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4301         st->codec->codec_id = codec->id;
4302         return codec;
4303     } else
4304         return avcodec_find_decoder(st->codec->codec_id);
4305 }
4306
4307 /**
4308  * Add all the streams from the given input file to the global
4309  * list of input streams.
4310  */
4311 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4312 {
4313     int i;
4314     char *next, *codec_tag = NULL;
4315
4316     for (i = 0; i < ic->nb_streams; i++) {
4317         AVStream *st = ic->streams[i];
4318         AVCodecContext *dec = st->codec;
4319         InputStream *ist = av_mallocz(sizeof(*ist));
4320         char *framerate = NULL;
4321
4322         if (!ist)
4323             exit_program(1);
4324
4325         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4326         input_streams[nb_input_streams - 1] = ist;
4327
4328         ist->st = st;
4329         ist->file_index = nb_input_files;
4330         ist->discard = 1;
4331         st->discard  = AVDISCARD_ALL;
4332         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
4333
4334         ist->ts_scale = 1.0;
4335         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4336
4337         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4338         if (codec_tag) {
4339             uint32_t tag = strtol(codec_tag, &next, 0);
4340             if (*next)
4341                 tag = AV_RL32(codec_tag);
4342             st->codec->codec_tag = tag;
4343         }
4344
4345         ist->dec = choose_decoder(o, ic, st);
4346
4347         switch (dec->codec_type) {
4348         case AVMEDIA_TYPE_VIDEO:
4349             if(!ist->dec)
4350                 ist->dec = avcodec_find_decoder(dec->codec_id);
4351             if (dec->lowres) {
4352                 dec->flags |= CODEC_FLAG_EMU_EDGE;
4353             }
4354
4355             ist->resample_height  = dec->height;
4356             ist->resample_width   = dec->width;
4357             ist->resample_pix_fmt = dec->pix_fmt;
4358
4359             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
4360             if (framerate && av_parse_video_rate(&ist->framerate,
4361                                                  framerate) < 0) {
4362                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
4363                        framerate);
4364                 exit_program(1);
4365             }
4366
4367             ist->top_field_first = -1;
4368             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
4369
4370             break;
4371         case AVMEDIA_TYPE_AUDIO:
4372             guess_input_channel_layout(ist);
4373
4374             ist->resample_sample_fmt     = dec->sample_fmt;
4375             ist->resample_sample_rate    = dec->sample_rate;
4376             ist->resample_channels       = dec->channels;
4377             ist->resample_channel_layout = dec->channel_layout;
4378
4379             break;
4380         case AVMEDIA_TYPE_DATA:
4381         case AVMEDIA_TYPE_SUBTITLE:
4382             if(!ist->dec)
4383                 ist->dec = avcodec_find_decoder(dec->codec_id);
4384             break;
4385         case AVMEDIA_TYPE_ATTACHMENT:
4386         case AVMEDIA_TYPE_UNKNOWN:
4387             break;
4388         default:
4389             abort();
4390         }
4391     }
4392 }
4393
4394 static void assert_file_overwrite(const char *filename)
4395 {
4396     if ((!file_overwrite || no_file_overwrite) &&
4397         (strchr(filename, ':') == NULL || filename[1] == ':' ||
4398          av_strstart(filename, "file:", NULL))) {
4399         if (avio_check(filename, 0) == 0) {
4400             if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
4401                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4402                 fflush(stderr);
4403                 term_exit();
4404                 signal(SIGINT, SIG_DFL);
4405                 if (!read_yesno()) {
4406                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4407                     exit_program(1);
4408                 }
4409                 term_init();
4410             }
4411             else {
4412                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4413                 exit_program(1);
4414             }
4415         }
4416     }
4417 }
4418
4419 static void dump_attachment(AVStream *st, const char *filename)
4420 {
4421     int ret;
4422     AVIOContext *out = NULL;
4423     AVDictionaryEntry *e;
4424
4425     if (!st->codec->extradata_size) {
4426         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4427                nb_input_files - 1, st->index);
4428         return;
4429     }
4430     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4431         filename = e->value;
4432     if (!*filename) {
4433         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4434                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4435         exit_program(1);
4436     }
4437
4438     assert_file_overwrite(filename);
4439
4440     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4441         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4442                filename);
4443         exit_program(1);
4444     }
4445
4446     avio_write(out, st->codec->extradata, st->codec->extradata_size);
4447     avio_flush(out);
4448     avio_close(out);
4449 }
4450
4451 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4452 {
4453     AVFormatContext *ic;
4454     AVInputFormat *file_iformat = NULL;
4455     int err, i, ret;
4456     int64_t timestamp;
4457     uint8_t buf[128];
4458     AVDictionary **opts;
4459     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
4460
4461     if (o->format) {
4462         if (!(file_iformat = av_find_input_format(o->format))) {
4463             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4464             exit_program(1);
4465         }
4466     }
4467
4468     if (!strcmp(filename, "-"))
4469         filename = "pipe:";
4470
4471     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
4472                          strcmp(filename, "/dev/stdin");
4473
4474     /* get default parameters from command line */
4475     ic = avformat_alloc_context();
4476     if (!ic) {
4477         print_error(filename, AVERROR(ENOMEM));
4478         exit_program(1);
4479     }
4480     if (o->nb_audio_sample_rate) {
4481         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4482         av_dict_set(&format_opts, "sample_rate", buf, 0);
4483     }
4484     if (o->nb_audio_channels) {
4485         /* because we set audio_channels based on both the "ac" and
4486          * "channel_layout" options, we need to check that the specified
4487          * demuxer actually has the "channels" option before setting it */
4488         if (file_iformat && file_iformat->priv_class &&
4489             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4490                         AV_OPT_SEARCH_FAKE_OBJ)) {
4491             snprintf(buf, sizeof(buf), "%d",
4492                      o->audio_channels[o->nb_audio_channels - 1].u.i);
4493             av_dict_set(&format_opts, "channels", buf, 0);
4494         }
4495     }
4496     if (o->nb_frame_rates) {
4497         /* set the format-level framerate option;
4498          * this is important for video grabbers, e.g. x11 */
4499         if (file_iformat && file_iformat->priv_class &&
4500             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
4501                         AV_OPT_SEARCH_FAKE_OBJ)) {
4502             av_dict_set(&format_opts, "framerate",
4503                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4504         }
4505     }
4506     if (o->nb_frame_sizes) {
4507         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4508     }
4509     if (o->nb_frame_pix_fmts)
4510         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4511
4512     ic->video_codec_id   = video_codec_name ?
4513         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
4514     ic->audio_codec_id   = audio_codec_name ?
4515         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
4516     ic->subtitle_codec_id= subtitle_codec_name ?
4517         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4518     ic->flags |= AVFMT_FLAG_NONBLOCK;
4519     ic->interrupt_callback = int_cb;
4520
4521     /* open the input file with generic avformat function */
4522     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4523     if (err < 0) {
4524         print_error(filename, err);
4525         exit_program(1);
4526     }
4527     assert_avoptions(format_opts);
4528
4529     /* apply forced codec ids */
4530     for (i = 0; i < ic->nb_streams; i++)
4531         choose_decoder(o, ic, ic->streams[i]);
4532
4533     /* Set AVCodecContext options for avformat_find_stream_info */
4534     opts = setup_find_stream_info_opts(ic, codec_opts);
4535     orig_nb_streams = ic->nb_streams;
4536
4537     /* If not enough info to get the stream parameters, we decode the
4538        first frames to get it. (used in mpeg case for example) */
4539     ret = avformat_find_stream_info(ic, opts);
4540     if (ret < 0) {
4541         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4542         avformat_close_input(&ic);
4543         exit_program(1);
4544     }
4545
4546     timestamp = o->start_time;
4547     /* add the stream start time */
4548     if (ic->start_time != AV_NOPTS_VALUE)
4549         timestamp += ic->start_time;
4550
4551     /* if seeking requested, we execute it */
4552     if (o->start_time != 0) {
4553         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4554         if (ret < 0) {
4555             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4556                    filename, (double)timestamp / AV_TIME_BASE);
4557         }
4558     }
4559
4560     /* update the current parameters so that they match the one of the input stream */
4561     add_input_streams(o, ic);
4562
4563     /* dump the file content */
4564     av_dump_format(ic, nb_input_files, filename, 0);
4565
4566     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4567     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4568         exit_program(1);
4569
4570     input_files[nb_input_files - 1]->ctx        = ic;
4571     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
4572     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4573     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4574     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
4575
4576     for (i = 0; i < o->nb_dump_attachment; i++) {
4577         int j;
4578
4579         for (j = 0; j < ic->nb_streams; j++) {
4580             AVStream *st = ic->streams[j];
4581
4582             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4583                 dump_attachment(st, o->dump_attachment[i].u.str);
4584         }
4585     }
4586
4587     for (i = 0; i < orig_nb_streams; i++)
4588         av_dict_free(&opts[i]);
4589     av_freep(&opts);
4590
4591     reset_options(o, 1);
4592     return 0;
4593 }
4594
4595 static uint8_t *get_line(AVIOContext *s)
4596 {
4597     AVIOContext *line;
4598     uint8_t *buf;
4599     char c;
4600
4601     if (avio_open_dyn_buf(&line) < 0) {
4602         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4603         exit_program(1);
4604     }
4605
4606     while ((c = avio_r8(s)) && c != '\n')
4607         avio_w8(line, c);
4608     avio_w8(line, 0);
4609     avio_close_dyn_buf(line, &buf);
4610
4611     return buf;
4612 }
4613
4614 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4615 {
4616     int i, ret = 1;
4617     char filename[1000];
4618     const char *base[3] = { getenv("AVCONV_DATADIR"),
4619                             getenv("HOME"),
4620                             AVCONV_DATADIR,
4621                             };
4622
4623     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4624         if (!base[i])
4625             continue;
4626         if (codec_name) {
4627             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4628                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
4629             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4630         }
4631         if (ret) {
4632             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4633                      i != 1 ? "" : "/.avconv", preset_name);
4634             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4635         }
4636     }
4637     return ret;
4638 }
4639
4640 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4641 {
4642     char *codec_name = NULL;
4643
4644     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4645     if (!codec_name) {
4646         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4647                                                   NULL, ost->st->codec->codec_type);
4648         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4649     } else if (!strcmp(codec_name, "copy"))
4650         ost->stream_copy = 1;
4651     else {
4652         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4653         ost->st->codec->codec_id = ost->enc->id;
4654     }
4655 }
4656
4657 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4658 {
4659     OutputStream *ost;
4660     AVStream *st = avformat_new_stream(oc, NULL);
4661     int idx      = oc->nb_streams - 1, ret = 0;
4662     char *bsf = NULL, *next, *codec_tag = NULL;
4663     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4664     double qscale = -1;
4665     char *buf = NULL, *arg = NULL, *preset = NULL;
4666     AVIOContext *s = NULL;
4667
4668     if (!st) {
4669         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4670         exit_program(1);
4671     }
4672
4673     if (oc->nb_streams - 1 < o->nb_streamid_map)
4674         st->id = o->streamid_map[oc->nb_streams - 1];
4675
4676     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4677                                 nb_output_streams + 1);
4678     if (!(ost = av_mallocz(sizeof(*ost))))
4679         exit_program(1);
4680     output_streams[nb_output_streams - 1] = ost;
4681
4682     ost->file_index = nb_output_files;
4683     ost->index      = idx;
4684     ost->st         = st;
4685     st->codec->codec_type = type;
4686     choose_encoder(o, oc, ost);
4687     if (ost->enc) {
4688         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
4689     }
4690
4691     avcodec_get_context_defaults3(st->codec, ost->enc);
4692     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4693
4694     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4695     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4696         do  {
4697             buf = get_line(s);
4698             if (!buf[0] || buf[0] == '#') {
4699                 av_free(buf);
4700                 continue;
4701             }
4702             if (!(arg = strchr(buf, '='))) {
4703                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4704                 exit_program(1);
4705             }
4706             *arg++ = 0;
4707             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4708             av_free(buf);
4709         } while (!s->eof_reached);
4710         avio_close(s);
4711     }
4712     if (ret) {
4713         av_log(NULL, AV_LOG_FATAL,
4714                "Preset %s specified for stream %d:%d, but could not be opened.\n",
4715                preset, ost->file_index, ost->index);
4716         exit_program(1);
4717     }
4718
4719     ost->max_frames = INT64_MAX;
4720     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4721
4722     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4723     while (bsf) {
4724         if (next = strchr(bsf, ','))
4725             *next++ = 0;
4726         if (!(bsfc = av_bitstream_filter_init(bsf))) {
4727             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4728             exit_program(1);
4729         }
4730         if (bsfc_prev)
4731             bsfc_prev->next = bsfc;
4732         else
4733             ost->bitstream_filters = bsfc;
4734
4735         bsfc_prev = bsfc;
4736         bsf       = next;
4737     }
4738
4739     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4740     if (codec_tag) {
4741         uint32_t tag = strtol(codec_tag, &next, 0);
4742         if (*next)
4743             tag = AV_RL32(codec_tag);
4744         st->codec->codec_tag = tag;
4745     }
4746
4747     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4748     if (qscale >= 0 || same_quant) {
4749         st->codec->flags |= CODEC_FLAG_QSCALE;
4750         st->codec->global_quality = FF_QP2LAMBDA * qscale;
4751     }
4752
4753     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4754         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4755
4756     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4757     av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4758     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4759
4760     ost->source_index = source_index;
4761     if (source_index >= 0) {
4762         ost->sync_ist = input_streams[source_index];
4763         input_streams[source_index]->discard = 0;
4764         input_streams[source_index]->st->discard = AVDISCARD_NONE;
4765     }
4766
4767     return ost;
4768 }
4769
4770 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4771 {
4772     int i;
4773     const char *p = str;
4774     for (i = 0;; i++) {
4775         dest[i] = atoi(p);
4776         if (i == 63)
4777             break;
4778         p = strchr(p, ',');
4779         if (!p) {
4780             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4781             exit_program(1);
4782         }
4783         p++;
4784     }
4785 }
4786
4787 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4788 {
4789     AVStream *st;
4790     OutputStream *ost;
4791     AVCodecContext *video_enc;
4792     char *frame_rate = NULL;
4793
4794     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4795     st  = ost->st;
4796     video_enc = st->codec;
4797
4798     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4799     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4800         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4801         exit_program(1);
4802     }
4803
4804     if (!ost->stream_copy) {
4805         const char *p = NULL;
4806         char *frame_size = NULL;
4807         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4808         char *intra_matrix = NULL, *inter_matrix = NULL;
4809         const char *filters = "null";
4810         int i;
4811
4812         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4813         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4814             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4815             exit_program(1);
4816         }
4817
4818         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4819         if (frame_aspect_ratio) {
4820             AVRational q;
4821             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4822                 q.num <= 0 || q.den <= 0) {
4823                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4824                 exit_program(1);
4825             }
4826             ost->frame_aspect_ratio = av_q2d(q);
4827         }
4828
4829         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4830         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4831         if (frame_pix_fmt && *frame_pix_fmt == '+') {
4832             ost->keep_pix_fmt = 1;
4833             if (!*++frame_pix_fmt)
4834                 frame_pix_fmt = NULL;
4835         }
4836         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4837             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4838             exit_program(1);
4839         }
4840         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4841
4842         if (intra_only)
4843             video_enc->gop_size = 0;
4844         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4845         if (intra_matrix) {
4846             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4847                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4848                 exit_program(1);
4849             }
4850             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4851         }
4852         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4853         if (inter_matrix) {
4854             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4855                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4856                 exit_program(1);
4857             }
4858             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4859         }
4860
4861         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4862         for (i = 0; p; i++) {
4863             int start, end, q;
4864             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4865             if (e != 3) {
4866                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4867                 exit_program(1);
4868             }
4869             /* FIXME realloc failure */
4870             video_enc->rc_override =
4871                 av_realloc(video_enc->rc_override,
4872                            sizeof(RcOverride) * (i + 1));
4873             video_enc->rc_override[i].start_frame = start;
4874             video_enc->rc_override[i].end_frame   = end;
4875             if (q > 0) {
4876                 video_enc->rc_override[i].qscale         = q;
4877                 video_enc->rc_override[i].quality_factor = 1.0;
4878             }
4879             else {
4880                 video_enc->rc_override[i].qscale         = 0;
4881                 video_enc->rc_override[i].quality_factor = -q/100.0;
4882             }
4883             p = strchr(p, '/');
4884             if (p) p++;
4885         }
4886         video_enc->rc_override_count = i;
4887         if (!video_enc->rc_initial_buffer_occupancy)
4888             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4889         video_enc->intra_dc_precision = intra_dc_precision - 8;
4890
4891         if (do_psnr)
4892             video_enc->flags|= CODEC_FLAG_PSNR;
4893
4894         /* two pass mode */
4895         if (do_pass) {
4896             if (do_pass & 1) {
4897                 video_enc->flags |= CODEC_FLAG_PASS1;
4898             }
4899             if (do_pass & 2) {
4900                 video_enc->flags |= CODEC_FLAG_PASS2;
4901             }
4902         }
4903
4904         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
4905         if (ost->forced_keyframes)
4906             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
4907
4908         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4909
4910         ost->top_field_first = -1;
4911         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4912
4913         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4914         ost->avfilter = av_strdup(filters);
4915     } else {
4916         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4917     }
4918
4919     return ost;
4920 }
4921
4922 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4923 {
4924     int n;
4925     AVStream *st;
4926     OutputStream *ost;
4927     AVCodecContext *audio_enc;
4928
4929     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4930     st  = ost->st;
4931
4932     audio_enc = st->codec;
4933     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4934
4935     if (!ost->stream_copy) {
4936         char *sample_fmt = NULL;
4937         const char *filters = "anull";
4938
4939         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4940
4941         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4942         if (sample_fmt &&
4943             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4944             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4945             exit_program(1);
4946         }
4947
4948         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4949
4950         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4951
4952         av_assert1(filters);
4953         ost->avfilter = av_strdup(filters);
4954
4955         /* check for channel mapping for this audio stream */
4956         for (n = 0; n < o->nb_audio_channel_maps; n++) {
4957             AudioChannelMap *map = &o->audio_channel_maps[n];
4958             InputStream *ist = input_streams[ost->source_index];
4959             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4960                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
4961                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
4962                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4963                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4964                 else
4965                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4966                            ost->file_index, ost->st->index);
4967             }
4968         }
4969     }
4970
4971     return ost;
4972 }
4973
4974 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4975 {
4976     OutputStream *ost;
4977
4978     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4979     if (!ost->stream_copy) {
4980         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4981         exit_program(1);
4982     }
4983
4984     return ost;
4985 }
4986
4987 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4988 {
4989     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4990     ost->stream_copy = 1;
4991     return ost;
4992 }
4993
4994 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4995 {
4996     AVStream *st;
4997     OutputStream *ost;
4998     AVCodecContext *subtitle_enc;
4999
5000     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
5001     st  = ost->st;
5002     subtitle_enc = st->codec;
5003
5004     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
5005
5006     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
5007
5008     return ost;
5009 }
5010
5011 /* arg format is "output-stream-index:streamid-value". */
5012 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
5013 {
5014     int idx;
5015     char *p;
5016     char idx_str[16];
5017
5018     av_strlcpy(idx_str, arg, sizeof(idx_str));
5019     p = strchr(idx_str, ':');
5020     if (!p) {
5021         av_log(NULL, AV_LOG_FATAL,
5022                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
5023                arg, opt);
5024         exit_program(1);
5025     }
5026     *p++ = '\0';
5027     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
5028     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
5029     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
5030     return 0;
5031 }
5032
5033 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
5034 {
5035     AVFormatContext *is = ifile->ctx;
5036     AVFormatContext *os = ofile->ctx;
5037     int i;
5038
5039     for (i = 0; i < is->nb_chapters; i++) {
5040         AVChapter *in_ch = is->chapters[i], *out_ch;
5041         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
5042                                        AV_TIME_BASE_Q, in_ch->time_base);
5043         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
5044                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
5045
5046
5047         if (in_ch->end < ts_off)
5048             continue;
5049         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
5050             break;
5051
5052         out_ch = av_mallocz(sizeof(AVChapter));
5053         if (!out_ch)
5054             return AVERROR(ENOMEM);
5055
5056         out_ch->id        = in_ch->id;
5057         out_ch->time_base = in_ch->time_base;
5058         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
5059         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
5060
5061         if (copy_metadata)
5062             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
5063
5064         os->nb_chapters++;
5065         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
5066         if (!os->chapters)
5067             return AVERROR(ENOMEM);
5068         os->chapters[os->nb_chapters - 1] = out_ch;
5069     }
5070     return 0;
5071 }
5072
5073 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
5074 {
5075     int i, err;
5076     AVFormatContext *ic = avformat_alloc_context();
5077
5078     ic->interrupt_callback = int_cb;
5079     err = avformat_open_input(&ic, filename, NULL, NULL);
5080     if (err < 0)
5081         return err;
5082     /* copy stream format */
5083     for(i=0;i<ic->nb_streams;i++) {
5084         AVStream *st;
5085         OutputStream *ost;
5086         AVCodec *codec;
5087         AVCodecContext *avctx;
5088
5089         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
5090         ost   = new_output_stream(o, s, codec->type, -1);
5091         st    = ost->st;
5092         avctx = st->codec;
5093         ost->enc = codec;
5094
5095         // FIXME: a more elegant solution is needed
5096         memcpy(st, ic->streams[i], sizeof(AVStream));
5097         st->cur_dts = 0;
5098         st->info = av_malloc(sizeof(*st->info));
5099         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
5100         st->codec= avctx;
5101         avcodec_copy_context(st->codec, ic->streams[i]->codec);
5102
5103         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
5104             choose_sample_fmt(st, codec);
5105         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
5106             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
5107     }
5108
5109     avformat_close_input(&ic);
5110     return 0;
5111 }
5112
5113 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
5114                                AVFormatContext *oc)
5115 {
5116     OutputStream *ost;
5117
5118     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
5119                                   ofilter->out_tmp->pad_idx)) {
5120     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
5121     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
5122     default:
5123         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
5124                "currently.\n");
5125         exit_program(1);
5126     }
5127
5128     ost->source_index = -1;
5129     ost->filter       = ofilter;
5130
5131     ofilter->ost      = ost;
5132
5133     if (ost->stream_copy) {
5134         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
5135                "which is fed from a complex filtergraph. Filtering and streamcopy "
5136                "cannot be used together.\n", ost->file_index, ost->index);
5137         exit_program(1);
5138     }
5139     if (o->recording_time != INT64_MAX)
5140         av_log(NULL, AV_LOG_WARNING,
5141                "-t does not work with -filter_complex (yet).\n");
5142
5143     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
5144         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
5145         exit_program(1);
5146     }
5147     avfilter_inout_free(&ofilter->out_tmp);
5148 }
5149
5150 static void opt_output_file(void *optctx, const char *filename)
5151 {
5152     OptionsContext *o = optctx;
5153     AVFormatContext *oc;
5154     int i, j, err;
5155     AVOutputFormat *file_oformat;
5156     OutputStream *ost;
5157     InputStream  *ist;
5158
5159     if (configure_complex_filters() < 0) {
5160         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
5161         exit_program(1);
5162     }
5163
5164     if (!strcmp(filename, "-"))
5165         filename = "pipe:";
5166
5167     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
5168     if (!oc) {
5169         print_error(filename, err);
5170         exit_program(1);
5171     }
5172     file_oformat= oc->oformat;
5173     oc->interrupt_callback = int_cb;
5174
5175     /* create streams for all unlabeled output pads */
5176     for (i = 0; i < nb_filtergraphs; i++) {
5177         FilterGraph *fg = filtergraphs[i];
5178         for (j = 0; j < fg->nb_outputs; j++) {
5179             OutputFilter *ofilter = fg->outputs[j];
5180
5181             if (!ofilter->out_tmp || ofilter->out_tmp->name)
5182                 continue;
5183
5184             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
5185                                           ofilter->out_tmp->pad_idx)) {
5186             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
5187             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
5188             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
5189             }
5190             init_output_filter(ofilter, o, oc);
5191         }
5192     }
5193
5194     if (!strcmp(file_oformat->name, "ffm") &&
5195         av_strstart(filename, "http:", NULL)) {
5196         int j;
5197         /* special case for files sent to ffserver: we get the stream
5198            parameters from ffserver */
5199         int err = read_ffserver_streams(o, oc, filename);
5200         if (err < 0) {
5201             print_error(filename, err);
5202             exit_program(1);
5203         }
5204         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
5205             ost = output_streams[j];
5206             for (i = 0; i < nb_input_streams; i++) {
5207                 ist = input_streams[i];
5208                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
5209                     ost->sync_ist= ist;
5210                     ost->source_index= i;
5211                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
5212                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
5213                     ist->discard = 0;
5214                     ist->st->discard = AVDISCARD_NONE;
5215                     break;
5216                 }
5217             }
5218             if(!ost->sync_ist){
5219                 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));
5220                 exit_program(1);
5221             }
5222         }
5223     } else if (!o->nb_stream_maps) {
5224         /* pick the "best" stream of each type */
5225
5226         /* video: highest resolution */
5227         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5228             int area = 0, idx = -1;
5229             for (i = 0; i < nb_input_streams; i++) {
5230                 ist = input_streams[i];
5231                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5232                     ist->st->codec->width * ist->st->codec->height > area) {
5233                     area = ist->st->codec->width * ist->st->codec->height;
5234                     idx = i;
5235                 }
5236             }
5237             if (idx >= 0)
5238                 new_video_stream(o, oc, idx);
5239         }
5240
5241         /* audio: most channels */
5242         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5243             int channels = 0, idx = -1;
5244             for (i = 0; i < nb_input_streams; i++) {
5245                 ist = input_streams[i];
5246                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5247                     ist->st->codec->channels > channels) {
5248                     channels = ist->st->codec->channels;
5249                     idx = i;
5250                 }
5251             }
5252             if (idx >= 0)
5253                 new_audio_stream(o, oc, idx);
5254         }
5255
5256         /* subtitles: pick first */
5257         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5258             for (i = 0; i < nb_input_streams; i++)
5259                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5260                     new_subtitle_stream(o, oc, i);
5261                     break;
5262                 }
5263         }
5264         /* do something with data? */
5265     } else {
5266         for (i = 0; i < o->nb_stream_maps; i++) {
5267             StreamMap *map = &o->stream_maps[i];
5268             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5269
5270             if (map->disabled)
5271                 continue;
5272
5273             if (map->linklabel) {
5274                 FilterGraph *fg;
5275                 OutputFilter *ofilter = NULL;
5276                 int j, k;
5277
5278                 for (j = 0; j < nb_filtergraphs; j++) {
5279                     fg = filtergraphs[j];
5280                     for (k = 0; k < fg->nb_outputs; k++) {
5281                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
5282                         if (out && !strcmp(out->name, map->linklabel)) {
5283                             ofilter = fg->outputs[k];
5284                             goto loop_end;
5285                         }
5286                     }
5287                 }
5288 loop_end:
5289                 if (!ofilter) {
5290                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5291                            "in any defined filter graph.\n", map->linklabel);
5292                     exit_program(1);
5293                 }
5294                 init_output_filter(ofilter, o, oc);
5295             } else {
5296                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5297                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5298                     continue;
5299                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5300                     continue;
5301                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5302                     continue;
5303                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5304                     continue;
5305
5306                 switch (ist->st->codec->codec_type) {
5307                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
5308                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
5309                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
5310                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
5311                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5312                 default:
5313                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5314                            map->file_index, map->stream_index);
5315                     exit_program(1);
5316                 }
5317             }
5318         }
5319     }
5320
5321
5322     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5323         AVDictionaryEntry *e;
5324         ost = output_streams[i];
5325
5326         if (   ost->stream_copy
5327             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5328             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5329             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5330                 exit_program(1);
5331     }
5332
5333     /* handle attached files */
5334     for (i = 0; i < o->nb_attachments; i++) {
5335         AVIOContext *pb;
5336         uint8_t *attachment;
5337         const char *p;
5338         int64_t len;
5339
5340         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5341             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5342                    o->attachments[i]);
5343             exit_program(1);
5344         }
5345         if ((len = avio_size(pb)) <= 0) {
5346             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5347                    o->attachments[i]);
5348             exit_program(1);
5349         }
5350         if (!(attachment = av_malloc(len))) {
5351             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5352                    o->attachments[i]);
5353             exit_program(1);
5354         }
5355         avio_read(pb, attachment, len);
5356
5357         ost = new_attachment_stream(o, oc, -1);
5358         ost->stream_copy               = 0;
5359         ost->attachment_filename       = o->attachments[i];
5360         ost->st->codec->extradata      = attachment;
5361         ost->st->codec->extradata_size = len;
5362
5363         p = strrchr(o->attachments[i], '/');
5364         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5365         avio_close(pb);
5366     }
5367
5368     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5369     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5370         exit_program(1);
5371
5372     output_files[nb_output_files - 1]->ctx            = oc;
5373     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
5374     output_files[nb_output_files - 1]->recording_time = o->recording_time;
5375     if (o->recording_time != INT64_MAX)
5376         oc->duration = o->recording_time;
5377     output_files[nb_output_files - 1]->start_time     = o->start_time;
5378     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5379     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5380
5381     /* check filename in case of an image number is expected */
5382     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5383         if (!av_filename_number_test(oc->filename)) {
5384             print_error(oc->filename, AVERROR(EINVAL));
5385             exit_program(1);
5386         }
5387     }
5388
5389     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5390         /* test if it already exists to avoid losing precious files */
5391         assert_file_overwrite(filename);
5392
5393         /* open the file */
5394         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5395                               &oc->interrupt_callback,
5396                               &output_files[nb_output_files - 1]->opts)) < 0) {
5397             print_error(filename, err);
5398             exit_program(1);
5399         }
5400     }
5401
5402     if (o->mux_preload) {
5403         uint8_t buf[64];
5404         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5405         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5406     }
5407     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5408
5409     /* copy metadata */
5410     for (i = 0; i < o->nb_metadata_map; i++) {
5411         char *p;
5412         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5413
5414         if (in_file_index >= nb_input_files) {
5415             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5416             exit_program(1);
5417         }
5418         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5419     }
5420
5421     /* copy chapters */
5422     if (o->chapters_input_file >= nb_input_files) {
5423         if (o->chapters_input_file == INT_MAX) {
5424             /* copy chapters from the first input file that has them*/
5425             o->chapters_input_file = -1;
5426             for (i = 0; i < nb_input_files; i++)
5427                 if (input_files[i]->ctx->nb_chapters) {
5428                     o->chapters_input_file = i;
5429                     break;
5430                 }
5431         } else {
5432             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5433                    o->chapters_input_file);
5434             exit_program(1);
5435         }
5436     }
5437     if (o->chapters_input_file >= 0)
5438         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5439                       !o->metadata_chapters_manual);
5440
5441     /* copy global metadata by default */
5442     if (!o->metadata_global_manual && nb_input_files){
5443         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5444                      AV_DICT_DONT_OVERWRITE);
5445         if(o->recording_time != INT64_MAX)
5446             av_dict_set(&oc->metadata, "duration", NULL, 0);
5447         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
5448     }
5449     if (!o->metadata_streams_manual)
5450         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5451             InputStream *ist;
5452             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
5453                 continue;
5454             ist = input_streams[output_streams[i]->source_index];
5455             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5456         }
5457
5458     /* process manually set metadata */
5459     for (i = 0; i < o->nb_metadata; i++) {
5460         AVDictionary **m;
5461         char type, *val;
5462         const char *stream_spec;
5463         int index = 0, j, ret = 0;
5464
5465         val = strchr(o->metadata[i].u.str, '=');
5466         if (!val) {
5467             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5468                    o->metadata[i].u.str);
5469             exit_program(1);
5470         }
5471         *val++ = 0;
5472
5473         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5474         if (type == 's') {
5475             for (j = 0; j < oc->nb_streams; j++) {
5476                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5477                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5478                 } else if (ret < 0)
5479                     exit_program(1);
5480             }
5481         }
5482         else {
5483             switch (type) {
5484             case 'g':
5485                 m = &oc->metadata;
5486                 break;
5487             case 'c':
5488                 if (index < 0 || index >= oc->nb_chapters) {
5489                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5490                     exit_program(1);
5491                 }
5492                 m = &oc->chapters[index]->metadata;
5493                 break;
5494             default:
5495                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5496                 exit_program(1);
5497             }
5498             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5499         }
5500     }
5501
5502     reset_options(o, 0);
5503 }
5504
5505 /* same option as mencoder */
5506 static int opt_pass(const char *opt, const char *arg)
5507 {
5508     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5509     return 0;
5510 }
5511
5512 static int64_t getmaxrss(void)
5513 {
5514 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5515     struct rusage rusage;
5516     getrusage(RUSAGE_SELF, &rusage);
5517     return (int64_t)rusage.ru_maxrss * 1024;
5518 #elif HAVE_GETPROCESSMEMORYINFO
5519     HANDLE proc;
5520     PROCESS_MEMORY_COUNTERS memcounters;
5521     proc = GetCurrentProcess();
5522     memcounters.cb = sizeof(memcounters);
5523     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5524     return memcounters.PeakPagefileUsage;
5525 #else
5526     return 0;
5527 #endif
5528 }
5529
5530 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5531 {
5532     return parse_option(o, "q:a", arg, options);
5533 }
5534
5535 static void show_usage(void)
5536 {
5537     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5538     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5539     av_log(NULL, AV_LOG_INFO, "\n");
5540 }
5541
5542 static int opt_help(const char *opt, const char *arg)
5543 {
5544     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5545     av_log_set_callback(log_callback_help);
5546     show_usage();
5547     show_help_options(options, "Main options:\n",
5548                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5549     show_help_options(options, "\nAdvanced options:\n",
5550                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5551                       OPT_EXPERT);
5552     show_help_options(options, "\nVideo options:\n",
5553                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5554                       OPT_VIDEO);
5555     show_help_options(options, "\nAdvanced Video options:\n",
5556                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5557                       OPT_VIDEO | OPT_EXPERT);
5558     show_help_options(options, "\nAudio options:\n",
5559                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5560                       OPT_AUDIO);
5561     show_help_options(options, "\nAdvanced Audio options:\n",
5562                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5563                       OPT_AUDIO | OPT_EXPERT);
5564     show_help_options(options, "\nSubtitle options:\n",
5565                       OPT_SUBTITLE | OPT_GRAB,
5566                       OPT_SUBTITLE);
5567     show_help_options(options, "\nAudio/Video grab options:\n",
5568                       OPT_GRAB,
5569                       OPT_GRAB);
5570     printf("\n");
5571     show_help_children(avcodec_get_class(), flags);
5572     show_help_children(avformat_get_class(), flags);
5573     show_help_children(sws_get_class(), flags);
5574     show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
5575
5576     return 0;
5577 }
5578
5579 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5580 {
5581     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5582     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5583
5584     if (!strncmp(arg, "pal-", 4)) {
5585         norm = PAL;
5586         arg += 4;
5587     } else if (!strncmp(arg, "ntsc-", 5)) {
5588         norm = NTSC;
5589         arg += 5;
5590     } else if (!strncmp(arg, "film-", 5)) {
5591         norm = FILM;
5592         arg += 5;
5593     } else {
5594         /* Try to determine PAL/NTSC by peeking in the input files */
5595         if (nb_input_files) {
5596             int i, j, fr;
5597             for (j = 0; j < nb_input_files; j++) {
5598                 for (i = 0; i < input_files[j]->nb_streams; i++) {
5599                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5600                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5601                         continue;
5602                     fr = c->time_base.den * 1000 / c->time_base.num;
5603                     if (fr == 25000) {
5604                         norm = PAL;
5605                         break;
5606                     } else if ((fr == 29970) || (fr == 23976)) {
5607                         norm = NTSC;
5608                         break;
5609                     }
5610                 }
5611                 if (norm != UNKNOWN)
5612                     break;
5613             }
5614         }
5615         if (norm != UNKNOWN)
5616             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5617     }
5618
5619     if (norm == UNKNOWN) {
5620         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5621         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5622         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5623         exit_program(1);
5624     }
5625
5626     if (!strcmp(arg, "vcd")) {
5627         opt_video_codec(o, "c:v", "mpeg1video");
5628         opt_audio_codec(o, "c:a", "mp2");
5629         parse_option(o, "f", "vcd", options);
5630
5631         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5632         parse_option(o, "r", frame_rates[norm], options);
5633         opt_default("g", norm == PAL ? "15" : "18");
5634
5635         opt_default("b:v", "1150000");
5636         opt_default("maxrate", "1150000");
5637         opt_default("minrate", "1150000");
5638         opt_default("bufsize", "327680"); // 40*1024*8;
5639
5640         opt_default("b:a", "224000");
5641         parse_option(o, "ar", "44100", options);
5642         parse_option(o, "ac", "2", options);
5643
5644         opt_default("packetsize", "2324");
5645         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5646
5647         /* We have to offset the PTS, so that it is consistent with the SCR.
5648            SCR starts at 36000, but the first two packs contain only padding
5649            and the first pack from the other stream, respectively, may also have
5650            been written before.
5651            So the real data starts at SCR 36000+3*1200. */
5652         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5653     } else if (!strcmp(arg, "svcd")) {
5654
5655         opt_video_codec(o, "c:v", "mpeg2video");
5656         opt_audio_codec(o, "c:a", "mp2");
5657         parse_option(o, "f", "svcd", options);
5658
5659         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5660         parse_option(o, "r", frame_rates[norm], options);
5661         parse_option(o, "pix_fmt", "yuv420p", options);
5662         opt_default("g", norm == PAL ? "15" : "18");
5663
5664         opt_default("b:v", "2040000");
5665         opt_default("maxrate", "2516000");
5666         opt_default("minrate", "0"); // 1145000;
5667         opt_default("bufsize", "1835008"); // 224*1024*8;
5668         opt_default("scan_offset", "1");
5669
5670
5671         opt_default("b:a", "224000");
5672         parse_option(o, "ar", "44100", options);
5673
5674         opt_default("packetsize", "2324");
5675
5676     } else if (!strcmp(arg, "dvd")) {
5677
5678         opt_video_codec(o, "c:v", "mpeg2video");
5679         opt_audio_codec(o, "c:a", "ac3");
5680         parse_option(o, "f", "dvd", options);
5681
5682         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5683         parse_option(o, "r", frame_rates[norm], options);
5684         parse_option(o, "pix_fmt", "yuv420p", options);
5685         opt_default("g", norm == PAL ? "15" : "18");
5686
5687         opt_default("b:v", "6000000");
5688         opt_default("maxrate", "9000000");
5689         opt_default("minrate", "0"); // 1500000;
5690         opt_default("bufsize", "1835008"); // 224*1024*8;
5691
5692         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5693         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5694
5695         opt_default("b:a", "448000");
5696         parse_option(o, "ar", "48000", options);
5697
5698     } else if (!strncmp(arg, "dv", 2)) {
5699
5700         parse_option(o, "f", "dv", options);
5701
5702         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5703         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5704                           norm == PAL ? "yuv420p" : "yuv411p", options);
5705         parse_option(o, "r", frame_rates[norm], options);
5706
5707         parse_option(o, "ar", "48000", options);
5708         parse_option(o, "ac", "2", options);
5709
5710     } else {
5711         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5712         return AVERROR(EINVAL);
5713     }
5714     return 0;
5715 }
5716
5717 static int opt_vstats_file(const char *opt, const char *arg)
5718 {
5719     av_free (vstats_filename);
5720     vstats_filename = av_strdup (arg);
5721     return 0;
5722 }
5723
5724 static int opt_vstats(const char *opt, const char *arg)
5725 {
5726     char filename[40];
5727     time_t today2 = time(NULL);
5728     struct tm *today = localtime(&today2);
5729
5730     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5731              today->tm_sec);
5732     return opt_vstats_file(opt, filename);
5733 }
5734
5735 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5736 {
5737     return parse_option(o, "frames:v", arg, options);
5738 }
5739
5740 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5741 {
5742     return parse_option(o, "frames:a", arg, options);
5743 }
5744
5745 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5746 {
5747     return parse_option(o, "frames:d", arg, options);
5748 }
5749
5750 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5751 {
5752     FILE *f=NULL;
5753     char filename[1000], line[1000], tmp_line[1000];
5754     const char *codec_name = *opt == 'v' ? video_codec_name :
5755                              *opt == 'a' ? audio_codec_name :
5756                                            subtitle_codec_name;
5757
5758     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5759         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5760             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5761         }else
5762             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5763         exit_program(1);
5764     }
5765
5766     while (fgets(line, sizeof(line), f)) {
5767         char *key = tmp_line, *value, *endptr;
5768
5769         if (strcspn(line, "#\n\r") == 0)
5770             continue;
5771         strcpy(tmp_line, line);
5772         if (!av_strtok(key,   "=",    &value) ||
5773             !av_strtok(value, "\r\n", &endptr)) {
5774             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5775             exit_program(1);
5776         }
5777         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5778
5779         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
5780         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
5781         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5782         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
5783         else if (opt_default(key, value) < 0) {
5784             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5785                    filename, line, key, value);
5786             exit_program(1);
5787         }
5788     }
5789
5790     fclose(f);
5791
5792     return 0;
5793 }
5794
5795 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5796 {
5797 }
5798
5799 static int opt_passlogfile(const char *opt, const char *arg)
5800 {
5801     pass_logfilename_prefix = arg;
5802 #if CONFIG_LIBX264_ENCODER
5803     return opt_default(opt, arg);
5804 #else
5805     return 0;
5806 #endif
5807 }
5808
5809 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5810 {
5811     char *s = av_asprintf("%s:%c", opt + 1, *opt);
5812     int ret = parse_option(o, s, arg, options);
5813     av_free(s);
5814     return ret;
5815 }
5816
5817 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5818 {
5819     if(!strcmp(opt, "b")){
5820         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5821         return parse_option(o, "b:v", arg, options);
5822     }
5823     return opt_default(opt, arg);
5824 }
5825
5826 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5827 {
5828     char *s;
5829     int ret;
5830     if(!strcmp(opt, "qscale")){
5831         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5832         return parse_option(o, "q:v", arg, options);
5833     }
5834     s = av_asprintf("q%s", opt + 6);
5835     ret = parse_option(o, s, arg, options);
5836     av_free(s);
5837     return ret;
5838 }
5839
5840 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5841 {
5842     if(!strcmp(opt, "profile")){
5843         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5844         return parse_option(o, "profile:v", arg, options);
5845     }
5846     return opt_default(opt, arg);
5847 }
5848
5849 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5850 {
5851     return parse_option(o, "filter:v", arg, options);
5852 }
5853
5854 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5855 {
5856     return parse_option(o, "filter:a", arg, options);
5857 }
5858
5859 static int opt_vsync(const char *opt, const char *arg)
5860 {
5861     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
5862     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
5863     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5864     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
5865
5866     if (video_sync_method == VSYNC_AUTO)
5867         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5868     return 0;
5869 }
5870
5871 static int opt_deinterlace(const char *opt, const char *arg)
5872 {
5873     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5874     do_deinterlace = 1;
5875     return 0;
5876 }
5877
5878 static int opt_timecode(OptionsContext *o, const char *opt, const char *arg)
5879 {
5880     char *tcr = av_asprintf("timecode=%s", arg);
5881     int ret = parse_option(o, "metadata:g", tcr, options);
5882     if (ret >= 0)
5883         ret = opt_default("gop_timecode", arg);
5884     av_free(tcr);
5885     return ret;
5886 }
5887
5888 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5889 {
5890     int idx = locate_option(argc, argv, options, "cpuflags");
5891     if (idx && argv[idx + 1])
5892         opt_cpuflags("cpuflags", argv[idx + 1]);
5893 }
5894
5895 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5896 {
5897     char layout_str[32];
5898     char *stream_str;
5899     char *ac_str;
5900     int ret, channels, ac_str_size;
5901     uint64_t layout;
5902
5903     layout = av_get_channel_layout(arg);
5904     if (!layout) {
5905         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5906         return AVERROR(EINVAL);
5907     }
5908     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5909     ret = opt_default(opt, layout_str);
5910     if (ret < 0)
5911         return ret;
5912
5913     /* set 'ac' option based on channel layout */
5914     channels = av_get_channel_layout_nb_channels(layout);
5915     snprintf(layout_str, sizeof(layout_str), "%d", channels);
5916     stream_str = strchr(opt, ':');
5917     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5918     ac_str = av_mallocz(ac_str_size);
5919     if (!ac_str)
5920         return AVERROR(ENOMEM);
5921     av_strlcpy(ac_str, "ac", 3);
5922     if (stream_str)
5923         av_strlcat(ac_str, stream_str, ac_str_size);
5924     ret = parse_option(o, ac_str, layout_str, options);
5925     av_free(ac_str);
5926
5927     return ret;
5928 }
5929
5930 static int opt_filter_complex(const char *opt, const char *arg)
5931 {
5932     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5933                               &nb_filtergraphs, nb_filtergraphs + 1);
5934     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5935         return AVERROR(ENOMEM);
5936     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
5937     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5938     return 0;
5939 }
5940
5941 static int opt_progress(const char *opt, const char *arg)
5942 {
5943     AVIOContext *avio = NULL;
5944     int ret;
5945
5946     if (!strcmp(arg, "-"))
5947         arg = "pipe:";
5948     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
5949     if (ret < 0) {
5950         av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
5951                arg, av_err2str(ret));
5952         return ret;
5953     }
5954     progress_avio = avio;
5955     return 0;
5956 }
5957
5958 #define OFFSET(x) offsetof(OptionsContext, x)
5959 static const OptionDef real_options[] = {
5960     /* main options */
5961 #include "cmdutils_common_opts.h"
5962     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5963     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5964     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5965     { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5966     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5967     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5968     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5969     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5970     { "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]" },
5971     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5972       "outfile[,metadata]:infile[,metadata]" },
5973     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
5974     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5975     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5976     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5977     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5978     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5979     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5980     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5981     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5982     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5983       "add timings for benchmarking" },
5984     { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5985       "add timings for each task" },
5986     { "progress", HAS_ARG | OPT_EXPERT, {(void*)opt_progress},
5987       "write program-readable progress information", "url" },
5988     { "stdin", OPT_BOOL | OPT_EXPERT, {(void*)&stdin_interaction},
5989       "enable or disable interaction on standard input" },
5990     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5991     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5992       "dump each input packet" },
5993     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5994       "when dumping packets, also dump the payload" },
5995     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5996     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5997     { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5998     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5999     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
6000     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
6001     { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying", "mode" },
6002     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
6003     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
6004     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
6005     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
6006     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
6007     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
6008     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
6009     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
6010     { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
6011     { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
6012     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
6013     { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
6014     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
6015     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
6016     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
6017     { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
6018
6019     /* video options */
6020     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
6021     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
6022     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
6023     { "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" },
6024     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
6025     { "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" },
6026     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
6027     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
6028     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
6029     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
6030     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
6031     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
6032     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
6033     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
6034     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
6035     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
6036     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
6037     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
6038     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
6039     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
6040     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
6041     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
6042       "use same quantizer as source (implies VBR)" },
6043     { "timecode", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_timecode}, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
6044     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
6045     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
6046     { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
6047       "this option is deprecated, use the yadif filter instead" },
6048     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
6049     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
6050     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
6051     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
6052     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
6053     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
6054     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
6055     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
6056     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
6057     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
6058     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
6059     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
6060     { "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" },
6061     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
6062
6063     /* audio options */
6064     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
6065     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
6066     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
6067     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
6068     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
6069     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
6070     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
6071     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
6072     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
6073     { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
6074     { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
6075
6076     /* subtitle options */
6077     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
6078     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
6079     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
6080
6081     /* grab options */
6082     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
6083     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
6084     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
6085
6086     /* muxer options */
6087     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
6088     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
6089
6090     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
6091     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
6092     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
6093
6094     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
6095     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
6096     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
6097     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
6098     /* data codec support */
6099     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
6100     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
6101
6102     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
6103     { NULL, },
6104 };
6105
6106 int main(int argc, char **argv)
6107 {
6108     OptionsContext o = { 0 };
6109     int64_t ti;
6110
6111     options = real_options;
6112     reset_options(&o, 0);
6113
6114     av_log_set_flags(AV_LOG_SKIP_REPEATED);
6115     parse_loglevel(argc, argv, options);
6116
6117     if(argc>1 && !strcmp(argv[1], "-d")){
6118         run_as_daemon=1;
6119         av_log_set_callback(log_callback_null);
6120         argc--;
6121         argv++;
6122     }
6123
6124     avcodec_register_all();
6125 #if CONFIG_AVDEVICE
6126     avdevice_register_all();
6127 #endif
6128     avfilter_register_all();
6129     av_register_all();
6130     avformat_network_init();
6131
6132     show_banner(argc, argv, options);
6133
6134     term_init();
6135
6136     parse_cpuflags(argc, argv, options);
6137
6138     /* parse options */
6139     parse_options(&o, argc, argv, options, opt_output_file);
6140
6141     if (nb_output_files <= 0 && nb_input_files == 0) {
6142         show_usage();
6143         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
6144         exit_program(1);
6145     }
6146
6147     /* file converter / grab */
6148     if (nb_output_files <= 0) {
6149         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
6150         exit_program(1);
6151     }
6152
6153     if (nb_input_files == 0) {
6154         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
6155         exit_program(1);
6156     }
6157
6158     current_time = ti = getutime();
6159     if (transcode() < 0)
6160         exit_program(1);
6161     ti = getutime() - ti;
6162     if (do_benchmark) {
6163         int maxrss = getmaxrss() / 1024;
6164         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
6165     }
6166
6167     exit_program(0);
6168     return 0;
6169 }