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