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