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