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