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