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