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 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do {                 \
1008     AVFilterContext *filt_ctx;                                              \
1009                                                                             \
1010     av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi "            \
1011            "similarly to -af " filter_name "=%s.\n", arg);                  \
1012                                                                             \
1013     ret = avfilter_graph_create_filter(&filt_ctx,                           \
1014                                        avfilter_get_by_name(filter_name),   \
1015                                        filter_name, arg, NULL, fg->graph);  \
1016     if (ret < 0)                                                            \
1017         return ret;                                                         \
1018                                                                             \
1019     ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0);                 \
1020     if (ret < 0)                                                            \
1021         return ret;                                                         \
1022                                                                             \
1023     last_filter = filt_ctx;                                                 \
1024     pad_idx = 0;                                                            \
1025 } while (0)
1026     if (ost->audio_channels_mapped) {
1027         int i;
1028         AVBPrint pan_buf;
1029         av_bprint_init(&pan_buf, 256, 8192);
1030         av_bprintf(&pan_buf, "0x%"PRIx64,
1031                    av_get_default_channel_layout(ost->audio_channels_mapped));
1032         for (i = 0; i < ost->audio_channels_mapped; i++)
1033             if (ost->audio_channels_map[i] != -1)
1034                 av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
1035
1036         AUTO_INSERT_FILTER("-map_channel", "pan", pan_buf.str);
1037         av_bprint_finalize(&pan_buf, NULL);
1038     }
1039
1040     if (codec->channels && !codec->channel_layout)
1041         codec->channel_layout = av_get_default_channel_layout(codec->channels);
1042
1043     sample_fmts     = choose_sample_fmts(ost);
1044     sample_rates    = choose_sample_rates(ost);
1045     channel_layouts = choose_channel_layouts(ost);
1046     if (sample_fmts || sample_rates || channel_layouts) {
1047         AVFilterContext *format;
1048         char args[256];
1049         int len = 0;
1050
1051         if (sample_fmts)
1052             len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
1053                             sample_fmts);
1054         if (sample_rates)
1055             len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
1056                             sample_rates);
1057         if (channel_layouts)
1058             len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
1059                             channel_layouts);
1060         args[len - 1] = 0;
1061
1062         av_freep(&sample_fmts);
1063         av_freep(&sample_rates);
1064         av_freep(&channel_layouts);
1065
1066         ret = avfilter_graph_create_filter(&format,
1067                                            avfilter_get_by_name("aformat"),
1068                                            "aformat", args, NULL, fg->graph);
1069         if (ret < 0)
1070             return ret;
1071
1072         ret = avfilter_link(last_filter, pad_idx, format, 0);
1073         if (ret < 0)
1074             return ret;
1075
1076         last_filter = format;
1077         pad_idx = 0;
1078     }
1079
1080     if (audio_sync_method > 0 && 0) {
1081         char args[256] = {0};
1082
1083         av_strlcatf(args, sizeof(args), "min_comp=0.001:min_hard_comp=%f", audio_drift_threshold);
1084         if (audio_sync_method > 1)
1085             av_strlcatf(args, sizeof(args), ":max_soft_comp=%d", -audio_sync_method);
1086         AUTO_INSERT_FILTER("-async", "aresample", args);
1087     }
1088
1089     if (audio_volume != 256) {
1090         char args[256];
1091
1092         snprintf(args, sizeof(args), "%f", audio_volume / 256.);
1093         AUTO_INSERT_FILTER("-vol", "volume", args);
1094     }
1095
1096     if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
1097         return ret;
1098
1099     return 0;
1100 }
1101
1102 #define DESCRIBE_FILTER_LINK(f, inout, in)                         \
1103 {                                                                  \
1104     AVFilterContext *ctx = inout->filter_ctx;                      \
1105     AVFilterPad *pads = in ? ctx->input_pads  : ctx->output_pads;  \
1106     int       nb_pads = in ? ctx->input_count : ctx->output_count; \
1107     AVIOContext *pb;                                               \
1108                                                                    \
1109     if (avio_open_dyn_buf(&pb) < 0)                                \
1110         exit_program(1);                                           \
1111                                                                    \
1112     avio_printf(pb, "%s", ctx->filter->name);                      \
1113     if (nb_pads > 1)                                               \
1114         avio_printf(pb, ":%s", pads[inout->pad_idx].name);         \
1115     avio_w8(pb, 0);                                                \
1116     avio_close_dyn_buf(pb, &f->name);                              \
1117 }
1118
1119 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
1120 {
1121     av_freep(&ofilter->name);
1122     DESCRIBE_FILTER_LINK(ofilter, out, 0);
1123
1124     switch (out->filter_ctx->output_pads[out->pad_idx].type) {
1125     case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
1126     case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
1127     default: av_assert0(0);
1128     }
1129 }
1130
1131 static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
1132                                         AVFilterInOut *in)
1133 {
1134     AVFilterContext *first_filter = in->filter_ctx;
1135     AVFilter *filter = avfilter_get_by_name("buffer");
1136     InputStream *ist = ifilter->ist;
1137     AVRational tb = ist->framerate.num ? (AVRational){ist->framerate.den,
1138                                                       ist->framerate.num} :
1139                                          ist->st->time_base;
1140     AVRational sar;
1141     char args[255];
1142     int pad_idx = in->pad_idx;
1143     int ret;
1144
1145     sar = ist->st->sample_aspect_ratio.num ?
1146           ist->st->sample_aspect_ratio :
1147           ist->st->codec->sample_aspect_ratio;
1148     snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
1149              ist->st->codec->height, ist->st->codec->pix_fmt,
1150              tb.num, tb.den, sar.num, sar.den,
1151              SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
1152
1153     if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter, in->name,
1154                                             args, NULL, fg->graph)) < 0)
1155         return ret;
1156
1157     if (ist->framerate.num) {
1158         AVFilterContext *setpts;
1159
1160         if ((ret = avfilter_graph_create_filter(&setpts,
1161                                                 avfilter_get_by_name("setpts"),
1162                                                 "setpts", "N", NULL,
1163                                                 fg->graph)) < 0)
1164             return ret;
1165
1166         if ((ret = avfilter_link(setpts, 0, first_filter, pad_idx)) < 0)
1167             return ret;
1168
1169         first_filter = setpts;
1170         pad_idx = 0;
1171     }
1172
1173     if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
1174         return ret;
1175     return 0;
1176 }
1177
1178 static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
1179                                         AVFilterInOut *in)
1180 {
1181     AVFilterContext *first_filter = in->filter_ctx;
1182     AVFilter *filter = avfilter_get_by_name("abuffer");
1183     InputStream *ist = ifilter->ist;
1184     int pad_idx = in->pad_idx;
1185     char args[255];
1186     int ret;
1187
1188     snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s"
1189              ":channel_layout=0x%"PRIx64,
1190              ist->st->time_base.num, ist->st->time_base.den,
1191              ist->st->codec->sample_rate,
1192              av_get_sample_fmt_name(ist->st->codec->sample_fmt),
1193              ist->st->codec->channel_layout);
1194
1195     if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter,
1196                                             in->name, args, NULL,
1197                                             fg->graph)) < 0)
1198         return ret;
1199
1200 #define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do {                 \
1201     AVFilterContext *filt_ctx;                                              \
1202                                                                             \
1203     av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi "            \
1204            "similarly to -af " filter_name "=%s.\n", arg);                  \
1205                                                                             \
1206     ret = avfilter_graph_create_filter(&filt_ctx,                           \
1207                                        avfilter_get_by_name(filter_name),   \
1208                                        filter_name, arg, NULL, fg->graph);  \
1209     if (ret < 0)                                                            \
1210         return ret;                                                         \
1211                                                                             \
1212     ret = avfilter_link(filt_ctx, 0, first_filter, pad_idx);                \
1213     if (ret < 0)                                                            \
1214         return ret;                                                         \
1215                                                                             \
1216     first_filter = filt_ctx;                                                  \
1217 } while (0)
1218
1219     if (audio_sync_method > 0) {
1220         char args[256] = {0};
1221
1222         av_strlcatf(args, sizeof(args), "min_comp=0.001:min_hard_comp=%f", audio_drift_threshold);
1223         if (audio_sync_method > 1)
1224             av_strlcatf(args, sizeof(args), ":max_soft_comp=%f", audio_sync_method/(double)ist->st->codec->sample_rate);
1225         AUTO_INSERT_FILTER_INPUT("-async", "aresample", args);
1226     }
1227
1228 //     if (ost->audio_channels_mapped) {
1229 //         int i;
1230 //         AVBPrint pan_buf;
1231 //         av_bprint_init(&pan_buf, 256, 8192);
1232 //         av_bprintf(&pan_buf, "0x%"PRIx64,
1233 //                    av_get_default_channel_layout(ost->audio_channels_mapped));
1234 //         for (i = 0; i < ost->audio_channels_mapped; i++)
1235 //             if (ost->audio_channels_map[i] != -1)
1236 //                 av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
1237 //         AUTO_INSERT_FILTER_INPUT("-map_channel", "pan", pan_buf.str);
1238 //         av_bprint_finalize(&pan_buf, NULL);
1239 //     }
1240
1241     if (audio_volume != 256) {
1242         char args[256];
1243
1244         snprintf(args, sizeof(args), "%f", audio_volume / 256.);
1245         AUTO_INSERT_FILTER_INPUT("-vol", "volume", args);
1246     }
1247     if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
1248         return ret;
1249
1250     return 0;
1251 }
1252
1253 static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter,
1254                                   AVFilterInOut *in)
1255 {
1256     av_freep(&ifilter->name);
1257     DESCRIBE_FILTER_LINK(ifilter, in, 1);
1258
1259     switch (in->filter_ctx->input_pads[in->pad_idx].type) {
1260     case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, ifilter, in);
1261     case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, ifilter, in);
1262     default: av_assert0(0);
1263     }
1264 }
1265
1266 static int configure_filtergraph(FilterGraph *fg)
1267 {
1268     AVFilterInOut *inputs, *outputs, *cur;
1269     int ret, i, init = !fg->graph, simple = !fg->graph_desc;
1270     const char *graph_desc = simple ? fg->outputs[0]->ost->avfilter :
1271                                       fg->graph_desc;
1272
1273     avfilter_graph_free(&fg->graph);
1274     if (!(fg->graph = avfilter_graph_alloc()))
1275         return AVERROR(ENOMEM);
1276
1277     if (simple) {
1278         OutputStream *ost = fg->outputs[0]->ost;
1279         char args[255];
1280         snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
1281         fg->graph->scale_sws_opts = av_strdup(args);
1282     }
1283
1284     if ((ret = avfilter_graph_parse2(fg->graph, graph_desc, &inputs, &outputs)) < 0)
1285         return ret;
1286
1287     if (simple && (!inputs || inputs->next || !outputs || outputs->next)) {
1288         av_log(NULL, AV_LOG_ERROR, "Simple filtergraph '%s' does not have "
1289                "exactly one input and output.\n", graph_desc);
1290         return AVERROR(EINVAL);
1291     }
1292
1293     for (cur = inputs; !simple && init && cur; cur = cur->next)
1294         init_input_filter(fg, cur);
1295
1296     for (cur = inputs, i = 0; cur; cur = cur->next, i++)
1297         if ((ret = configure_input_filter(fg, fg->inputs[i], cur)) < 0)
1298             return ret;
1299     avfilter_inout_free(&inputs);
1300
1301     if (!init || simple) {
1302         /* we already know the mappings between lavfi outputs and output streams,
1303          * so we can finish the setup */
1304         for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1305             configure_output_filter(fg, fg->outputs[i], cur);
1306         avfilter_inout_free(&outputs);
1307
1308         if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1309             return ret;
1310     } else {
1311         /* wait until output mappings are processed */
1312         for (cur = outputs; cur;) {
1313             fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1314                                      &fg->nb_outputs, fg->nb_outputs + 1);
1315             if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1316                 exit_program(1);
1317             fg->outputs[fg->nb_outputs - 1]->graph   = fg;
1318             fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1319             cur = cur->next;
1320             fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1321         }
1322     }
1323
1324     return 0;
1325 }
1326
1327 static int configure_complex_filters(void)
1328 {
1329     int i, ret = 0;
1330
1331     for (i = 0; i < nb_filtergraphs; i++)
1332         if (!filtergraphs[i]->graph &&
1333             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1334             return ret;
1335     return 0;
1336 }
1337
1338 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1339 {
1340     int i;
1341     for (i = 0; i < fg->nb_inputs; i++)
1342         if (fg->inputs[i]->ist == ist)
1343             return 1;
1344     return 0;
1345 }
1346
1347 static void term_exit(void)
1348 {
1349     av_log(NULL, AV_LOG_QUIET, "%s", "");
1350 #if HAVE_TERMIOS_H
1351     if(restore_tty)
1352         tcsetattr (0, TCSANOW, &oldtty);
1353 #endif
1354 }
1355
1356 static volatile int received_sigterm = 0;
1357
1358 static void sigterm_handler(int sig)
1359 {
1360     received_sigterm = sig;
1361     received_nb_signals++;
1362     term_exit();
1363     if(received_nb_signals > 3)
1364         exit(123);
1365 }
1366
1367 static void term_init(void)
1368 {
1369 #if HAVE_TERMIOS_H
1370     if(!run_as_daemon){
1371         struct termios tty;
1372
1373         if (tcgetattr (0, &tty) == 0) {
1374             oldtty = tty;
1375             restore_tty = 1;
1376             atexit(term_exit);
1377
1378             tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1379                              |INLCR|IGNCR|ICRNL|IXON);
1380             tty.c_oflag |= OPOST;
1381             tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1382             tty.c_cflag &= ~(CSIZE|PARENB);
1383             tty.c_cflag |= CS8;
1384             tty.c_cc[VMIN] = 1;
1385             tty.c_cc[VTIME] = 0;
1386
1387             tcsetattr (0, TCSANOW, &tty);
1388         }
1389         signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
1390     }
1391 #endif
1392     avformat_network_deinit();
1393
1394     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
1395     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
1396 #ifdef SIGXCPU
1397     signal(SIGXCPU, sigterm_handler);
1398 #endif
1399 }
1400
1401 /* read a key without blocking */
1402 static int read_key(void)
1403 {
1404     unsigned char ch;
1405 #if HAVE_TERMIOS_H
1406     int n = 1;
1407     struct timeval tv;
1408     fd_set rfds;
1409
1410     FD_ZERO(&rfds);
1411     FD_SET(0, &rfds);
1412     tv.tv_sec = 0;
1413     tv.tv_usec = 0;
1414     n = select(1, &rfds, NULL, NULL, &tv);
1415     if (n > 0) {
1416         n = read(0, &ch, 1);
1417         if (n == 1)
1418             return ch;
1419
1420         return n;
1421     }
1422 #elif HAVE_KBHIT
1423 #    if HAVE_PEEKNAMEDPIPE
1424     static int is_pipe;
1425     static HANDLE input_handle;
1426     DWORD dw, nchars;
1427     if(!input_handle){
1428         input_handle = GetStdHandle(STD_INPUT_HANDLE);
1429         is_pipe = !GetConsoleMode(input_handle, &dw);
1430     }
1431
1432     if (stdin->_cnt > 0) {
1433         read(0, &ch, 1);
1434         return ch;
1435     }
1436     if (is_pipe) {
1437         /* When running under a GUI, you will end here. */
1438         if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1439             return -1;
1440         //Read it
1441         if(nchars != 0) {
1442             read(0, &ch, 1);
1443             return ch;
1444         }else{
1445             return -1;
1446         }
1447     }
1448 #    endif
1449     if(kbhit())
1450         return(getch());
1451 #endif
1452     return -1;
1453 }
1454
1455 static int decode_interrupt_cb(void *ctx)
1456 {
1457     return received_nb_signals > 1;
1458 }
1459
1460 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1461
1462 void av_noreturn exit_program(int ret)
1463 {
1464     int i, j;
1465
1466     for (i = 0; i < nb_filtergraphs; i++) {
1467         avfilter_graph_free(&filtergraphs[i]->graph);
1468         for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
1469             av_freep(&filtergraphs[i]->inputs[j]->name);
1470             av_freep(&filtergraphs[i]->inputs[j]);
1471         }
1472         av_freep(&filtergraphs[i]->inputs);
1473         for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
1474             av_freep(&filtergraphs[i]->outputs[j]->name);
1475             av_freep(&filtergraphs[i]->outputs[j]);
1476         }
1477         av_freep(&filtergraphs[i]->outputs);
1478         av_freep(&filtergraphs[i]);
1479     }
1480     av_freep(&filtergraphs);
1481
1482     /* close files */
1483     for (i = 0; i < nb_output_files; i++) {
1484         AVFormatContext *s = output_files[i]->ctx;
1485         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1486             avio_close(s->pb);
1487         avformat_free_context(s);
1488         av_dict_free(&output_files[i]->opts);
1489         av_freep(&output_files[i]);
1490     }
1491     for (i = 0; i < nb_output_streams; i++) {
1492         AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1493         while (bsfc) {
1494             AVBitStreamFilterContext *next = bsfc->next;
1495             av_bitstream_filter_close(bsfc);
1496             bsfc = next;
1497         }
1498         output_streams[i]->bitstream_filters = NULL;
1499
1500         av_freep(&output_streams[i]->filtered_frame);
1501         av_freep(&output_streams[i]->avfilter);
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 (!icodec ||
3107                     codec->width   != icodec->width  ||
3108                     codec->height  != icodec->height ||
3109                     codec->pix_fmt != icodec->pix_fmt) {
3110                     codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3111                 }
3112
3113                 break;
3114             case AVMEDIA_TYPE_SUBTITLE:
3115                 codec->time_base = (AVRational){1, 1000};
3116                 break;
3117             default:
3118                 abort();
3119                 break;
3120             }
3121             /* two pass mode */
3122             if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3123                 char logfilename[1024];
3124                 FILE *f;
3125
3126                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3127                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3128                          i);
3129                 if (!strcmp(ost->enc->name, "libx264")) {
3130                     av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3131                 } else {
3132                     if (codec->flags & CODEC_FLAG_PASS2) {
3133                         char  *logbuffer;
3134                         size_t logbuffer_size;
3135                         if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3136                             av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3137                                    logfilename);
3138                             exit_program(1);
3139                         }
3140                         codec->stats_in = logbuffer;
3141                     }
3142                     if (codec->flags & CODEC_FLAG_PASS1) {
3143                         f = fopen(logfilename, "wb");
3144                         if (!f) {
3145                             av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3146                                 logfilename, strerror(errno));
3147                             exit_program(1);
3148                         }
3149                         ost->logfile = f;
3150                     }
3151                 }
3152             }
3153         }
3154     }
3155
3156     /* open each encoder */
3157     for (i = 0; i < nb_output_streams; i++) {
3158         ost = output_streams[i];
3159         if (ost->encoding_needed) {
3160             AVCodec      *codec = ost->enc;
3161             AVCodecContext *dec = NULL;
3162
3163             if ((ist = get_input_stream(ost)))
3164                 dec = ist->st->codec;
3165             if (dec && dec->subtitle_header) {
3166                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3167                 if (!ost->st->codec->subtitle_header) {
3168                     ret = AVERROR(ENOMEM);
3169                     goto dump_format;
3170                 }
3171                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3172                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3173             }
3174             if (!av_dict_get(ost->opts, "threads", NULL, 0))
3175                 av_dict_set(&ost->opts, "threads", "auto", 0);
3176             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3177                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3178                         ost->file_index, ost->index);
3179                 ret = AVERROR(EINVAL);
3180                 goto dump_format;
3181             }
3182             assert_codec_experimental(ost->st->codec, 1);
3183             assert_avoptions(ost->opts);
3184             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3185                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3186                                              " It takes bits/s as argument, not kbits/s\n");
3187             extra_size += ost->st->codec->extradata_size;
3188
3189             if (ost->st->codec->me_threshold)
3190                 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3191         }
3192     }
3193
3194     /* init input streams */
3195     for (i = 0; i < nb_input_streams; i++)
3196         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3197             goto dump_format;
3198
3199     /* discard unused programs */
3200     for (i = 0; i < nb_input_files; i++) {
3201         InputFile *ifile = input_files[i];
3202         for (j = 0; j < ifile->ctx->nb_programs; j++) {
3203             AVProgram *p = ifile->ctx->programs[j];
3204             int discard  = AVDISCARD_ALL;
3205
3206             for (k = 0; k < p->nb_stream_indexes; k++)
3207                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3208                     discard = AVDISCARD_DEFAULT;
3209                     break;
3210                 }
3211             p->discard = discard;
3212         }
3213     }
3214
3215     /* open files and write file headers */
3216     for (i = 0; i < nb_output_files; i++) {
3217         oc = output_files[i]->ctx;
3218         oc->interrupt_callback = int_cb;
3219         if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3220             char errbuf[128];
3221             const char *errbuf_ptr = errbuf;
3222             if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
3223                 errbuf_ptr = strerror(AVUNERROR(ret));
3224             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
3225             ret = AVERROR(EINVAL);
3226             goto dump_format;
3227         }
3228 //         assert_avoptions(output_files[i]->opts);
3229         if (strcmp(oc->oformat->name, "rtp")) {
3230             want_sdp = 0;
3231         }
3232     }
3233
3234  dump_format:
3235     /* dump the file output parameters - cannot be done before in case
3236        of stream copy */
3237     for (i = 0; i < nb_output_files; i++) {
3238         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3239     }
3240
3241     /* dump the stream mapping */
3242     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3243     for (i = 0; i < nb_input_streams; i++) {
3244         ist = input_streams[i];
3245
3246         for (j = 0; j < ist->nb_filters; j++) {
3247             if (ist->filters[j]->graph->graph_desc) {
3248                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
3249                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3250                        ist->filters[j]->name);
3251                 if (nb_filtergraphs > 1)
3252                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3253                 av_log(NULL, AV_LOG_INFO, "\n");
3254             }
3255         }
3256     }
3257
3258     for (i = 0; i < nb_output_streams; i++) {
3259         ost = output_streams[i];
3260
3261         if (ost->attachment_filename) {
3262             /* an attached file */
3263             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
3264                    ost->attachment_filename, ost->file_index, ost->index);
3265             continue;
3266         }
3267
3268         if (ost->filter && ost->filter->graph->graph_desc) {
3269             /* output from a complex graph */
3270             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
3271             if (nb_filtergraphs > 1)
3272                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3273
3274             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3275                    ost->index, ost->enc ? ost->enc->name : "?");
3276             continue;
3277         }
3278
3279         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
3280                input_streams[ost->source_index]->file_index,
3281                input_streams[ost->source_index]->st->index,
3282                ost->file_index,
3283                ost->index);
3284         if (ost->sync_ist != input_streams[ost->source_index])
3285             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3286                    ost->sync_ist->file_index,
3287                    ost->sync_ist->st->index);
3288         if (ost->stream_copy)
3289             av_log(NULL, AV_LOG_INFO, " (copy)");
3290         else
3291             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3292                    input_streams[ost->source_index]->dec->name : "?",
3293                    ost->enc ? ost->enc->name : "?");
3294         av_log(NULL, AV_LOG_INFO, "\n");
3295     }
3296
3297     if (ret) {
3298         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3299         return ret;
3300     }
3301
3302     if (want_sdp) {
3303         print_sdp();
3304     }
3305
3306     return 0;
3307 }
3308
3309 /*
3310  * The following code is the main loop of the file converter
3311  */
3312 static int transcode(void)
3313 {
3314     int ret, i;
3315     AVFormatContext *is, *os;
3316     OutputStream *ost;
3317     InputStream *ist;
3318     uint8_t *no_packet;
3319     int no_packet_count = 0;
3320     int64_t timer_start;
3321     int key;
3322
3323     if (!(no_packet = av_mallocz(nb_input_files)))
3324         exit_program(1);
3325
3326     ret = transcode_init();
3327     if (ret < 0)
3328         goto fail;
3329
3330     if (!using_stdin) {
3331         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3332     }
3333
3334     timer_start = av_gettime();
3335
3336     for (; received_sigterm == 0;) {
3337         int file_index, ist_index, past_recording_time = 1;
3338         AVPacket pkt;
3339         int64_t ipts_min;
3340         int64_t cur_time= av_gettime();
3341
3342         ipts_min = INT64_MAX;
3343         /* if 'q' pressed, exits */
3344         if (!using_stdin) {
3345             static int64_t last_time;
3346             if (received_nb_signals)
3347                 break;
3348             /* read_key() returns 0 on EOF */
3349             if(cur_time - last_time >= 100000 && !run_as_daemon){
3350                 key =  read_key();
3351                 last_time = cur_time;
3352             }else
3353                 key = -1;
3354             if (key == 'q')
3355                 break;
3356             if (key == '+') av_log_set_level(av_log_get_level()+10);
3357             if (key == '-') av_log_set_level(av_log_get_level()-10);
3358             if (key == 's') qp_hist     ^= 1;
3359             if (key == 'h'){
3360                 if (do_hex_dump){
3361                     do_hex_dump = do_pkt_dump = 0;
3362                 } else if(do_pkt_dump){
3363                     do_hex_dump = 1;
3364                 } else
3365                     do_pkt_dump = 1;
3366                 av_log_set_level(AV_LOG_DEBUG);
3367             }
3368             if (key == 'c' || key == 'C'){
3369                 char buf[4096], target[64], command[256], arg[256] = {0};
3370                 double time;
3371                 int k, n = 0;
3372                 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3373                 i = 0;
3374                 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3375                     if (k > 0)
3376                         buf[i++] = k;
3377                 buf[i] = 0;
3378                 if (k > 0 &&
3379                     (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3380                     av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3381                            target, time, command, arg);
3382                     for (i = 0; i < nb_filtergraphs; i++) {
3383                         FilterGraph *fg = filtergraphs[i];
3384                         if (fg->graph) {
3385                             if (time < 0) {
3386                                 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3387                                                                   key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3388                                 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3389                             } else {
3390                                 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3391                             }
3392                         }
3393                     }
3394                 } else {
3395                     av_log(NULL, AV_LOG_ERROR,
3396                            "Parse error, at least 3 arguments were expected, "
3397                            "only %d given in string '%s'\n", n, buf);
3398                 }
3399             }
3400             if (key == 'd' || key == 'D'){
3401                 int debug=0;
3402                 if(key == 'D') {
3403                     debug = input_streams[0]->st->codec->debug<<1;
3404                     if(!debug) debug = 1;
3405                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3406                         debug += debug;
3407                 }else
3408                     if(scanf("%d", &debug)!=1)
3409                         fprintf(stderr,"error parsing debug value\n");
3410                 for(i=0;i<nb_input_streams;i++) {
3411                     input_streams[i]->st->codec->debug = debug;
3412                 }
3413                 for(i=0;i<nb_output_streams;i++) {
3414                     ost = output_streams[i];
3415                     ost->st->codec->debug = debug;
3416                 }
3417                 if(debug) av_log_set_level(AV_LOG_DEBUG);
3418                 fprintf(stderr,"debug=%d\n", debug);
3419             }
3420             if (key == '?'){
3421                 fprintf(stderr, "key    function\n"
3422                                 "?      show this help\n"
3423                                 "+      increase verbosity\n"
3424                                 "-      decrease verbosity\n"
3425                                 "c      Send command to filtergraph\n"
3426                                 "D      cycle through available debug modes\n"
3427                                 "h      dump packets/hex press to cycle through the 3 states\n"
3428                                 "q      quit\n"
3429                                 "s      Show QP histogram\n"
3430                 );
3431             }
3432         }
3433
3434         /* check if there's any stream where output is still needed */
3435         for (i = 0; i < nb_output_streams; i++) {
3436             OutputFile *of;
3437             ost = output_streams[i];
3438             of  = output_files[ost->file_index];
3439             os  = output_files[ost->file_index]->ctx;
3440             if (ost->is_past_recording_time ||
3441                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3442                 continue;
3443             if (ost->frame_number >= ost->max_frames) {
3444                 int j;
3445                 for (j = 0; j < of->ctx->nb_streams; j++)
3446                     output_streams[of->ost_index + j]->is_past_recording_time = 1;
3447                 continue;
3448             }
3449             past_recording_time = 0;
3450         }
3451         if (past_recording_time)
3452             break;
3453
3454         /* select the stream that we must read now by looking at the
3455            smallest output pts */
3456         file_index = -1;
3457         for (i = 0; i < nb_input_streams; i++) {
3458             int64_t ipts;
3459             ist = input_streams[i];
3460             ipts = ist->pts;
3461             if (ist->discard || no_packet[ist->file_index])
3462                 continue;
3463             if (!input_files[ist->file_index]->eof_reached) {
3464                 if (ipts < ipts_min) {
3465                     ipts_min = ipts;
3466                     file_index = ist->file_index;
3467                 }
3468             }
3469         }
3470         /* if none, if is finished */
3471         if (file_index < 0) {
3472             if (no_packet_count) {
3473                 no_packet_count = 0;
3474                 memset(no_packet, 0, nb_input_files);
3475                 usleep(10000);
3476                 continue;
3477             }
3478             break;
3479         }
3480
3481         /* read a frame from it and output it in the fifo */
3482         is  = input_files[file_index]->ctx;
3483         ret = av_read_frame(is, &pkt);
3484         if (ret == AVERROR(EAGAIN)) {
3485             no_packet[file_index] = 1;
3486             no_packet_count++;
3487             continue;
3488         }
3489         if (ret < 0) {
3490             input_files[file_index]->eof_reached = 1;
3491
3492             for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3493                 ist = input_streams[input_files[file_index]->ist_index + i];
3494                 if (ist->decoding_needed)
3495                     output_packet(ist, NULL);
3496             }
3497
3498             if (opt_shortest)
3499                 break;
3500             else
3501                 continue;
3502         }
3503
3504         no_packet_count = 0;
3505         memset(no_packet, 0, nb_input_files);
3506
3507         if (do_pkt_dump) {
3508             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3509                              is->streams[pkt.stream_index]);
3510         }
3511         /* the following test is needed in case new streams appear
3512            dynamically in stream : we ignore them */
3513         if (pkt.stream_index >= input_files[file_index]->nb_streams)
3514             goto discard_packet;
3515         ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3516         ist = input_streams[ist_index];
3517         if (ist->discard)
3518             goto discard_packet;
3519
3520         if (pkt.dts != AV_NOPTS_VALUE)
3521             pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3522         if (pkt.pts != AV_NOPTS_VALUE)
3523             pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3524
3525         if (pkt.pts != AV_NOPTS_VALUE)
3526             pkt.pts *= ist->ts_scale;
3527         if (pkt.dts != AV_NOPTS_VALUE)
3528             pkt.dts *= ist->ts_scale;
3529
3530         if (debug_ts) {
3531             av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3532                     "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",
3533                     ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3534                     av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3535                     av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3536                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3537                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3538                     input_files[ist->file_index]->ts_offset);
3539         }
3540
3541         if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3542             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3543             int64_t delta   = pkt_dts - ist->next_dts;
3544             if (is->iformat->flags & AVFMT_TS_DISCONT) {
3545             if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3546                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3547                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3548                 pkt_dts+1<ist->pts){
3549                 input_files[ist->file_index]->ts_offset -= delta;
3550                 av_log(NULL, AV_LOG_DEBUG,
3551                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3552                        delta, input_files[ist->file_index]->ts_offset);
3553                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3554                 if (pkt.pts != AV_NOPTS_VALUE)
3555                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3556             }
3557             } else {
3558                 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3559                     (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3560                      pkt_dts+1<ist->pts){
3561                     av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3562                     pkt.dts = AV_NOPTS_VALUE;
3563                 }
3564                 if (pkt.pts != AV_NOPTS_VALUE){
3565                     int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3566                     delta   = pkt_pts - ist->next_dts;
3567                     if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3568                         (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3569                         pkt_pts+1<ist->pts) {
3570                         av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3571                         pkt.pts = AV_NOPTS_VALUE;
3572                     }
3573                 }
3574             }
3575         }
3576
3577         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3578         if (output_packet(ist, &pkt) < 0 ||
3579             ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3580             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3581                    ist->file_index, ist->st->index);
3582             if (exit_on_error)
3583                 exit_program(1);
3584             av_free_packet(&pkt);
3585             continue;
3586         }
3587
3588     discard_packet:
3589         av_free_packet(&pkt);
3590
3591         /* dump report by using the output first video and audio streams */
3592         print_report(0, timer_start, cur_time);
3593     }
3594
3595     /* at the end of stream, we must flush the decoder buffers */
3596     for (i = 0; i < nb_input_streams; i++) {
3597         ist = input_streams[i];
3598         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3599             output_packet(ist, NULL);
3600         }
3601     }
3602     poll_filters();
3603     flush_encoders();
3604
3605     term_exit();
3606
3607     /* write the trailer if needed and close file */
3608     for (i = 0; i < nb_output_files; i++) {
3609         os = output_files[i]->ctx;
3610         av_write_trailer(os);
3611     }
3612
3613     /* dump report by using the first video and audio streams */
3614     print_report(1, timer_start, av_gettime());
3615
3616     /* close each encoder */
3617     for (i = 0; i < nb_output_streams; i++) {
3618         ost = output_streams[i];
3619         if (ost->encoding_needed) {
3620             av_freep(&ost->st->codec->stats_in);
3621             avcodec_close(ost->st->codec);
3622         }
3623     }
3624
3625     /* close each decoder */
3626     for (i = 0; i < nb_input_streams; i++) {
3627         ist = input_streams[i];
3628         if (ist->decoding_needed) {
3629             avcodec_close(ist->st->codec);
3630         }
3631     }
3632
3633     /* finished ! */
3634     ret = 0;
3635
3636  fail:
3637     av_freep(&no_packet);
3638
3639     if (output_streams) {
3640         for (i = 0; i < nb_output_streams; i++) {
3641             ost = output_streams[i];
3642             if (ost) {
3643                 if (ost->stream_copy)
3644                     av_freep(&ost->st->codec->extradata);
3645                 if (ost->logfile) {
3646                     fclose(ost->logfile);
3647                     ost->logfile = NULL;
3648                 }
3649                 av_freep(&ost->st->codec->subtitle_header);
3650                 av_free(ost->forced_kf_pts);
3651                 av_dict_free(&ost->opts);
3652             }
3653         }
3654     }
3655     return ret;
3656 }
3657
3658 static int opt_frame_crop(const char *opt, const char *arg)
3659 {
3660     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3661     return AVERROR(EINVAL);
3662 }
3663
3664 static int opt_pad(const char *opt, const char *arg)
3665 {
3666     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3667     return -1;
3668 }
3669
3670 static int opt_video_channel(const char *opt, const char *arg)
3671 {
3672     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3673     return opt_default("channel", arg);
3674 }
3675
3676 static int opt_video_standard(const char *opt, const char *arg)
3677 {
3678     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3679     return opt_default("standard", arg);
3680 }
3681
3682 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3683 {
3684     audio_codec_name = arg;
3685     return parse_option(o, "codec:a", arg, options);
3686 }
3687
3688 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3689 {
3690     video_codec_name = arg;
3691     return parse_option(o, "codec:v", arg, options);
3692 }
3693
3694 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3695 {
3696     subtitle_codec_name = arg;
3697     return parse_option(o, "codec:s", arg, options);
3698 }
3699
3700 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3701 {
3702     return parse_option(o, "codec:d", arg, options);
3703 }
3704
3705 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3706 {
3707     StreamMap *m = NULL;
3708     int i, negative = 0, file_idx;
3709     int sync_file_idx = -1, sync_stream_idx = 0;
3710     char *p, *sync;
3711     char *map;
3712
3713     if (*arg == '-') {
3714         negative = 1;
3715         arg++;
3716     }
3717     map = av_strdup(arg);
3718
3719     /* parse sync stream first, just pick first matching stream */
3720     if (sync = strchr(map, ',')) {
3721         *sync = 0;
3722         sync_file_idx = strtol(sync + 1, &sync, 0);
3723         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3724             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3725             exit_program(1);
3726         }
3727         if (*sync)
3728             sync++;
3729         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3730             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3731                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3732                 sync_stream_idx = i;
3733                 break;
3734             }
3735         if (i == input_files[sync_file_idx]->nb_streams) {
3736             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3737                                        "match any streams.\n", arg);
3738             exit_program(1);
3739         }
3740     }
3741
3742
3743     if (map[0] == '[') {
3744         /* this mapping refers to lavfi output */
3745         const char *c = map + 1;
3746         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3747                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
3748         m = &o->stream_maps[o->nb_stream_maps - 1];
3749         m->linklabel = av_get_token(&c, "]");
3750         if (!m->linklabel) {
3751             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3752             exit_program(1);
3753         }
3754     } else {
3755         file_idx = strtol(map, &p, 0);
3756         if (file_idx >= nb_input_files || file_idx < 0) {
3757             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3758             exit_program(1);
3759         }
3760         if (negative)
3761             /* disable some already defined maps */
3762             for (i = 0; i < o->nb_stream_maps; i++) {
3763                 m = &o->stream_maps[i];
3764                 if (file_idx == m->file_index &&
3765                     check_stream_specifier(input_files[m->file_index]->ctx,
3766                                            input_files[m->file_index]->ctx->streams[m->stream_index],
3767                                            *p == ':' ? p + 1 : p) > 0)
3768                     m->disabled = 1;
3769             }
3770         else
3771             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3772                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3773                             *p == ':' ? p + 1 : p) <= 0)
3774                     continue;
3775                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3776                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
3777                 m = &o->stream_maps[o->nb_stream_maps - 1];
3778
3779                 m->file_index   = file_idx;
3780                 m->stream_index = i;
3781
3782                 if (sync_file_idx >= 0) {
3783                     m->sync_file_index   = sync_file_idx;
3784                     m->sync_stream_index = sync_stream_idx;
3785                 } else {
3786                     m->sync_file_index   = file_idx;
3787                     m->sync_stream_index = i;
3788                 }
3789             }
3790     }
3791
3792     if (!m) {
3793         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3794         exit_program(1);
3795     }
3796
3797     av_freep(&map);
3798     return 0;
3799 }
3800
3801 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3802 {
3803     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3804                                 &o->nb_attachments, o->nb_attachments + 1);
3805     o->attachments[o->nb_attachments - 1] = arg;
3806     return 0;
3807 }
3808
3809 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3810 {
3811     int n;
3812     AVStream *st;
3813     AudioChannelMap *m;
3814
3815     o->audio_channel_maps =
3816         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3817                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3818     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3819
3820     /* muted channel syntax */
3821     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3822     if ((n == 1 || n == 3) && m->channel_idx == -1) {
3823         m->file_idx = m->stream_idx = -1;
3824         if (n == 1)
3825             m->ofile_idx = m->ostream_idx = -1;
3826         return 0;
3827     }
3828
3829     /* normal syntax */
3830     n = sscanf(arg, "%d.%d.%d:%d.%d",
3831                &m->file_idx,  &m->stream_idx, &m->channel_idx,
3832                &m->ofile_idx, &m->ostream_idx);
3833
3834     if (n != 3 && n != 5) {
3835         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3836                "[file.stream.channel|-1][:syncfile:syncstream]\n");
3837         exit_program(1);
3838     }
3839
3840     if (n != 5) // only file.stream.channel specified
3841         m->ofile_idx = m->ostream_idx = -1;
3842
3843     /* check input */
3844     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3845         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3846                m->file_idx);
3847         exit_program(1);
3848     }
3849     if (m->stream_idx < 0 ||
3850         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3851         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3852                m->file_idx, m->stream_idx);
3853         exit_program(1);
3854     }
3855     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3856     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3857         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3858                m->file_idx, m->stream_idx);
3859         exit_program(1);
3860     }
3861     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3862         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3863                m->file_idx, m->stream_idx, m->channel_idx);
3864         exit_program(1);
3865     }
3866     return 0;
3867 }
3868
3869 /**
3870  * Parse a metadata specifier in arg.
3871  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3872  * @param index for type c/p, chapter/program index is written here
3873  * @param stream_spec for type s, the stream specifier is written here
3874  */
3875 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3876 {
3877     if (*arg) {
3878         *type = *arg;
3879         switch (*arg) {
3880         case 'g':
3881             break;
3882         case 's':
3883             if (*(++arg) && *arg != ':') {
3884                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3885                 exit_program(1);
3886             }
3887             *stream_spec = *arg == ':' ? arg + 1 : "";
3888             break;
3889         case 'c':
3890         case 'p':
3891             if (*(++arg) == ':')
3892                 *index = strtol(++arg, NULL, 0);
3893             break;
3894         default:
3895             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3896             exit_program(1);
3897         }
3898     } else
3899         *type = 'g';
3900 }
3901
3902 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3903 {
3904     AVDictionary **meta_in = NULL;
3905     AVDictionary **meta_out = NULL;
3906     int i, ret = 0;
3907     char type_in, type_out;
3908     const char *istream_spec = NULL, *ostream_spec = NULL;
3909     int idx_in = 0, idx_out = 0;
3910
3911     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
3912     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3913
3914     if (!ic) {
3915         if (type_out == 'g' || !*outspec)
3916             o->metadata_global_manual = 1;
3917         if (type_out == 's' || !*outspec)
3918             o->metadata_streams_manual = 1;
3919         if (type_out == 'c' || !*outspec)
3920             o->metadata_chapters_manual = 1;
3921         return 0;
3922     }
3923
3924     if (type_in == 'g' || type_out == 'g')
3925         o->metadata_global_manual = 1;
3926     if (type_in == 's' || type_out == 's')
3927         o->metadata_streams_manual = 1;
3928     if (type_in == 'c' || type_out == 'c')
3929         o->metadata_chapters_manual = 1;
3930
3931 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3932     if ((index) < 0 || (index) >= (nb_elems)) {\
3933         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3934                 (desc), (index));\
3935         exit_program(1);\
3936     }
3937
3938 #define SET_DICT(type, meta, context, index)\
3939         switch (type) {\
3940         case 'g':\
3941             meta = &context->metadata;\
3942             break;\
3943         case 'c':\
3944             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3945             meta = &context->chapters[index]->metadata;\
3946             break;\
3947         case 'p':\
3948             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3949             meta = &context->programs[index]->metadata;\
3950             break;\
3951         }\
3952
3953     SET_DICT(type_in, meta_in, ic, idx_in);
3954     SET_DICT(type_out, meta_out, oc, idx_out);
3955
3956     /* for input streams choose first matching stream */
3957     if (type_in == 's') {
3958         for (i = 0; i < ic->nb_streams; i++) {
3959             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3960                 meta_in = &ic->streams[i]->metadata;
3961                 break;
3962             } else if (ret < 0)
3963                 exit_program(1);
3964         }
3965         if (!meta_in) {
3966             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
3967             exit_program(1);
3968         }
3969     }
3970
3971     if (type_out == 's') {
3972         for (i = 0; i < oc->nb_streams; i++) {
3973             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3974                 meta_out = &oc->streams[i]->metadata;
3975                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3976             } else if (ret < 0)
3977                 exit_program(1);
3978         }
3979     } else
3980         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3981
3982     return 0;
3983 }
3984
3985 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3986 {
3987     char buf[128];
3988     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3989     struct tm time = *gmtime((time_t*)&recording_timestamp);
3990     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3991     parse_option(o, "metadata", buf, options);
3992
3993     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3994                                  "tag instead.\n", opt);
3995     return 0;
3996 }
3997
3998 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3999 {
4000     const char *codec_string = encoder ? "encoder" : "decoder";
4001     AVCodec *codec;
4002
4003     codec = encoder ?
4004         avcodec_find_encoder_by_name(name) :
4005         avcodec_find_decoder_by_name(name);
4006     if (!codec) {
4007         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4008         exit_program(1);
4009     }
4010     if (codec->type != type) {
4011         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4012         exit_program(1);
4013     }
4014     return codec;
4015 }
4016
4017 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4018 {
4019     char *codec_name = NULL;
4020
4021     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4022     if (codec_name) {
4023         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4024         st->codec->codec_id = codec->id;
4025         return codec;
4026     } else
4027         return avcodec_find_decoder(st->codec->codec_id);
4028 }
4029
4030 /**
4031  * Add all the streams from the given input file to the global
4032  * list of input streams.
4033  */
4034 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4035 {
4036     int i;
4037     char *next, *codec_tag = NULL;
4038
4039     for (i = 0; i < ic->nb_streams; i++) {
4040         AVStream *st = ic->streams[i];
4041         AVCodecContext *dec = st->codec;
4042         InputStream *ist = av_mallocz(sizeof(*ist));
4043         char *framerate = NULL;
4044
4045         if (!ist)
4046             exit_program(1);
4047
4048         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4049         input_streams[nb_input_streams - 1] = ist;
4050
4051         ist->st = st;
4052         ist->file_index = nb_input_files;
4053         ist->discard = 1;
4054         st->discard  = AVDISCARD_ALL;
4055         ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
4056
4057         ist->ts_scale = 1.0;
4058         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4059
4060         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4061         if (codec_tag) {
4062             uint32_t tag = strtol(codec_tag, &next, 0);
4063             if (*next)
4064                 tag = AV_RL32(codec_tag);
4065             st->codec->codec_tag = tag;
4066         }
4067
4068         ist->dec = choose_decoder(o, ic, st);
4069
4070         switch (dec->codec_type) {
4071         case AVMEDIA_TYPE_VIDEO:
4072             if(!ist->dec)
4073                 ist->dec = avcodec_find_decoder(dec->codec_id);
4074             if (dec->lowres) {
4075                 dec->flags |= CODEC_FLAG_EMU_EDGE;
4076             }
4077
4078             ist->resample_height  = dec->height;
4079             ist->resample_width   = dec->width;
4080             ist->resample_pix_fmt = dec->pix_fmt;
4081
4082             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
4083             if (framerate && av_parse_video_rate(&ist->framerate,
4084                                                  framerate) < 0) {
4085                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
4086                        framerate);
4087                 exit_program(1);
4088             }
4089
4090             ist->top_field_first = -1;
4091             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
4092
4093             break;
4094         case AVMEDIA_TYPE_AUDIO:
4095             guess_input_channel_layout(ist);
4096
4097             ist->resample_sample_fmt     = dec->sample_fmt;
4098             ist->resample_sample_rate    = dec->sample_rate;
4099             ist->resample_channels       = dec->channels;
4100             ist->resample_channel_layout = dec->channel_layout;
4101
4102             break;
4103         case AVMEDIA_TYPE_DATA:
4104         case AVMEDIA_TYPE_SUBTITLE:
4105             if(!ist->dec)
4106                 ist->dec = avcodec_find_decoder(dec->codec_id);
4107             break;
4108         case AVMEDIA_TYPE_ATTACHMENT:
4109         case AVMEDIA_TYPE_UNKNOWN:
4110             break;
4111         default:
4112             abort();
4113         }
4114     }
4115 }
4116
4117 static void assert_file_overwrite(const char *filename)
4118 {
4119     if ((!file_overwrite || no_file_overwrite) &&
4120         (strchr(filename, ':') == NULL || filename[1] == ':' ||
4121          av_strstart(filename, "file:", NULL))) {
4122         if (avio_check(filename, 0) == 0) {
4123             if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4124                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4125                 fflush(stderr);
4126                 term_exit();
4127                 signal(SIGINT, SIG_DFL);
4128                 if (!read_yesno()) {
4129                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4130                     exit_program(1);
4131                 }
4132                 term_init();
4133             }
4134             else {
4135                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4136                 exit_program(1);
4137             }
4138         }
4139     }
4140 }
4141
4142 static void dump_attachment(AVStream *st, const char *filename)
4143 {
4144     int ret;
4145     AVIOContext *out = NULL;
4146     AVDictionaryEntry *e;
4147
4148     if (!st->codec->extradata_size) {
4149         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4150                nb_input_files - 1, st->index);
4151         return;
4152     }
4153     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4154         filename = e->value;
4155     if (!*filename) {
4156         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4157                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4158         exit_program(1);
4159     }
4160
4161     assert_file_overwrite(filename);
4162
4163     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4164         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4165                filename);
4166         exit_program(1);
4167     }
4168
4169     avio_write(out, st->codec->extradata, st->codec->extradata_size);
4170     avio_flush(out);
4171     avio_close(out);
4172 }
4173
4174 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4175 {
4176     AVFormatContext *ic;
4177     AVInputFormat *file_iformat = NULL;
4178     int err, i, ret;
4179     int64_t timestamp;
4180     uint8_t buf[128];
4181     AVDictionary **opts;
4182     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
4183
4184     if (o->format) {
4185         if (!(file_iformat = av_find_input_format(o->format))) {
4186             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4187             exit_program(1);
4188         }
4189     }
4190
4191     if (!strcmp(filename, "-"))
4192         filename = "pipe:";
4193
4194     using_stdin |= !strncmp(filename, "pipe:", 5) ||
4195                     !strcmp(filename, "/dev/stdin");
4196
4197     /* get default parameters from command line */
4198     ic = avformat_alloc_context();
4199     if (!ic) {
4200         print_error(filename, AVERROR(ENOMEM));
4201         exit_program(1);
4202     }
4203     if (o->nb_audio_sample_rate) {
4204         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4205         av_dict_set(&format_opts, "sample_rate", buf, 0);
4206     }
4207     if (o->nb_audio_channels) {
4208         /* because we set audio_channels based on both the "ac" and
4209          * "channel_layout" options, we need to check that the specified
4210          * demuxer actually has the "channels" option before setting it */
4211         if (file_iformat && file_iformat->priv_class &&
4212             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4213                         AV_OPT_SEARCH_FAKE_OBJ)) {
4214             snprintf(buf, sizeof(buf), "%d",
4215                      o->audio_channels[o->nb_audio_channels - 1].u.i);
4216             av_dict_set(&format_opts, "channels", buf, 0);
4217         }
4218     }
4219     if (o->nb_frame_rates) {
4220         /* set the format-level framerate option;
4221          * this is important for video grabbers, e.g. x11 */
4222         if (file_iformat && file_iformat->priv_class &&
4223             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
4224                         AV_OPT_SEARCH_FAKE_OBJ)) {
4225             av_dict_set(&format_opts, "framerate",
4226                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4227         }
4228     }
4229     if (o->nb_frame_sizes) {
4230         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4231     }
4232     if (o->nb_frame_pix_fmts)
4233         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4234
4235     ic->video_codec_id   = video_codec_name ?
4236         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
4237     ic->audio_codec_id   = audio_codec_name ?
4238         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
4239     ic->subtitle_codec_id= subtitle_codec_name ?
4240         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4241     ic->flags |= AVFMT_FLAG_NONBLOCK;
4242     ic->interrupt_callback = int_cb;
4243
4244     /* open the input file with generic avformat function */
4245     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4246     if (err < 0) {
4247         print_error(filename, err);
4248         exit_program(1);
4249     }
4250     assert_avoptions(format_opts);
4251
4252     /* apply forced codec ids */
4253     for (i = 0; i < ic->nb_streams; i++)
4254         choose_decoder(o, ic, ic->streams[i]);
4255
4256     /* Set AVCodecContext options for avformat_find_stream_info */
4257     opts = setup_find_stream_info_opts(ic, codec_opts);
4258     orig_nb_streams = ic->nb_streams;
4259
4260     /* If not enough info to get the stream parameters, we decode the
4261        first frames to get it. (used in mpeg case for example) */
4262     ret = avformat_find_stream_info(ic, opts);
4263     if (ret < 0) {
4264         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4265         avformat_close_input(&ic);
4266         exit_program(1);
4267     }
4268
4269     timestamp = o->start_time;
4270     /* add the stream start time */
4271     if (ic->start_time != AV_NOPTS_VALUE)
4272         timestamp += ic->start_time;
4273
4274     /* if seeking requested, we execute it */
4275     if (o->start_time != 0) {
4276         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4277         if (ret < 0) {
4278             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4279                    filename, (double)timestamp / AV_TIME_BASE);
4280         }
4281     }
4282
4283     /* update the current parameters so that they match the one of the input stream */
4284     add_input_streams(o, ic);
4285
4286     /* dump the file content */
4287     av_dump_format(ic, nb_input_files, filename, 0);
4288
4289     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4290     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4291         exit_program(1);
4292
4293     input_files[nb_input_files - 1]->ctx        = ic;
4294     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
4295     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4296     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4297     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
4298
4299     for (i = 0; i < o->nb_dump_attachment; i++) {
4300         int j;
4301
4302         for (j = 0; j < ic->nb_streams; j++) {
4303             AVStream *st = ic->streams[j];
4304
4305             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4306                 dump_attachment(st, o->dump_attachment[i].u.str);
4307         }
4308     }
4309
4310     for (i = 0; i < orig_nb_streams; i++)
4311         av_dict_free(&opts[i]);
4312     av_freep(&opts);
4313
4314     reset_options(o, 1);
4315     return 0;
4316 }
4317
4318 static void parse_forced_key_frames(char *kf, OutputStream *ost)
4319 {
4320     char *p;
4321     int n = 1, i;
4322
4323     for (p = kf; *p; p++)
4324         if (*p == ',')
4325             n++;
4326     ost->forced_kf_count = n;
4327     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
4328     if (!ost->forced_kf_pts) {
4329         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
4330         exit_program(1);
4331     }
4332     p = kf;
4333     for (i = 0; i < n; i++) {
4334         char *next = strchr(p, ',');
4335         if (next) *next++ = 0;
4336         ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
4337         p = next;
4338     }
4339 }
4340
4341 static uint8_t *get_line(AVIOContext *s)
4342 {
4343     AVIOContext *line;
4344     uint8_t *buf;
4345     char c;
4346
4347     if (avio_open_dyn_buf(&line) < 0) {
4348         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4349         exit_program(1);
4350     }
4351
4352     while ((c = avio_r8(s)) && c != '\n')
4353         avio_w8(line, c);
4354     avio_w8(line, 0);
4355     avio_close_dyn_buf(line, &buf);
4356
4357     return buf;
4358 }
4359
4360 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4361 {
4362     int i, ret = 1;
4363     char filename[1000];
4364     const char *base[3] = { getenv("AVCONV_DATADIR"),
4365                             getenv("HOME"),
4366                             AVCONV_DATADIR,
4367                             };
4368
4369     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4370         if (!base[i])
4371             continue;
4372         if (codec_name) {
4373             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4374                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
4375             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4376         }
4377         if (ret) {
4378             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4379                      i != 1 ? "" : "/.avconv", preset_name);
4380             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4381         }
4382     }
4383     return ret;
4384 }
4385
4386 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4387 {
4388     char *codec_name = NULL;
4389
4390     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4391     if (!codec_name) {
4392         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4393                                                   NULL, ost->st->codec->codec_type);
4394         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4395     } else if (!strcmp(codec_name, "copy"))
4396         ost->stream_copy = 1;
4397     else {
4398         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4399         ost->st->codec->codec_id = ost->enc->id;
4400     }
4401 }
4402
4403 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4404 {
4405     OutputStream *ost;
4406     AVStream *st = avformat_new_stream(oc, NULL);
4407     int idx      = oc->nb_streams - 1, ret = 0;
4408     char *bsf = NULL, *next, *codec_tag = NULL;
4409     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4410     double qscale = -1;
4411     char *buf = NULL, *arg = NULL, *preset = NULL;
4412     AVIOContext *s = NULL;
4413
4414     if (!st) {
4415         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4416         exit_program(1);
4417     }
4418
4419     if (oc->nb_streams - 1 < o->nb_streamid_map)
4420         st->id = o->streamid_map[oc->nb_streams - 1];
4421
4422     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4423                                 nb_output_streams + 1);
4424     if (!(ost = av_mallocz(sizeof(*ost))))
4425         exit_program(1);
4426     output_streams[nb_output_streams - 1] = ost;
4427
4428     ost->file_index = nb_output_files;
4429     ost->index      = idx;
4430     ost->st         = st;
4431     st->codec->codec_type = type;
4432     choose_encoder(o, oc, ost);
4433     if (ost->enc) {
4434         ost->opts  = filter_codec_opts(codec_opts, ost->enc, oc, st);
4435     }
4436
4437     avcodec_get_context_defaults3(st->codec, ost->enc);
4438     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4439
4440     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4441     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4442         do  {
4443             buf = get_line(s);
4444             if (!buf[0] || buf[0] == '#') {
4445                 av_free(buf);
4446                 continue;
4447             }
4448             if (!(arg = strchr(buf, '='))) {
4449                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4450                 exit_program(1);
4451             }
4452             *arg++ = 0;
4453             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4454             av_free(buf);
4455         } while (!s->eof_reached);
4456         avio_close(s);
4457     }
4458     if (ret) {
4459         av_log(NULL, AV_LOG_FATAL,
4460                "Preset %s specified for stream %d:%d, but could not be opened.\n",
4461                preset, ost->file_index, ost->index);
4462         exit_program(1);
4463     }
4464
4465     ost->max_frames = INT64_MAX;
4466     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4467
4468     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4469     while (bsf) {
4470         if (next = strchr(bsf, ','))
4471             *next++ = 0;
4472         if (!(bsfc = av_bitstream_filter_init(bsf))) {
4473             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4474             exit_program(1);
4475         }
4476         if (bsfc_prev)
4477             bsfc_prev->next = bsfc;
4478         else
4479             ost->bitstream_filters = bsfc;
4480
4481         bsfc_prev = bsfc;
4482         bsf       = next;
4483     }
4484
4485     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4486     if (codec_tag) {
4487         uint32_t tag = strtol(codec_tag, &next, 0);
4488         if (*next)
4489             tag = AV_RL32(codec_tag);
4490         st->codec->codec_tag = tag;
4491     }
4492
4493     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4494     if (qscale >= 0 || same_quant) {
4495         st->codec->flags |= CODEC_FLAG_QSCALE;
4496         st->codec->global_quality = FF_QP2LAMBDA * qscale;
4497     }
4498
4499     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4500         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4501
4502     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4503     av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4504     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4505
4506     ost->source_index = source_index;
4507     if (source_index >= 0) {
4508         ost->sync_ist = input_streams[source_index];
4509         input_streams[source_index]->discard = 0;
4510         input_streams[source_index]->st->discard = AVDISCARD_NONE;
4511     }
4512
4513     return ost;
4514 }
4515
4516 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4517 {
4518     int i;
4519     const char *p = str;
4520     for (i = 0;; i++) {
4521         dest[i] = atoi(p);
4522         if (i == 63)
4523             break;
4524         p = strchr(p, ',');
4525         if (!p) {
4526             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4527             exit_program(1);
4528         }
4529         p++;
4530     }
4531 }
4532
4533 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4534 {
4535     AVStream *st;
4536     OutputStream *ost;
4537     AVCodecContext *video_enc;
4538
4539     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4540     st  = ost->st;
4541     video_enc = st->codec;
4542
4543     if (!ost->stream_copy) {
4544         const char *p = NULL;
4545         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4546         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4547         char *intra_matrix = NULL, *inter_matrix = NULL;
4548         const char *filters = "null";
4549         int i;
4550
4551         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4552         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4553             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4554             exit_program(1);
4555         }
4556
4557         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4558         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4559             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4560             exit_program(1);
4561         }
4562
4563         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4564         if (frame_aspect_ratio) {
4565             AVRational q;
4566             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4567                 q.num <= 0 || q.den <= 0) {
4568                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4569                 exit_program(1);
4570             }
4571             ost->frame_aspect_ratio = av_q2d(q);
4572         }
4573
4574         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4575         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4576         if (frame_pix_fmt && *frame_pix_fmt == '+') {
4577             ost->keep_pix_fmt = 1;
4578             if (!*++frame_pix_fmt)
4579                 frame_pix_fmt = NULL;
4580         }
4581         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4582             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4583             exit_program(1);
4584         }
4585         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4586
4587         if (intra_only)
4588             video_enc->gop_size = 0;
4589         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4590         if (intra_matrix) {
4591             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4592                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4593                 exit_program(1);
4594             }
4595             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4596         }
4597         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4598         if (inter_matrix) {
4599             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4600                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4601                 exit_program(1);
4602             }
4603             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4604         }
4605
4606         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4607         for (i = 0; p; i++) {
4608             int start, end, q;
4609             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4610             if (e != 3) {
4611                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4612                 exit_program(1);
4613             }
4614             /* FIXME realloc failure */
4615             video_enc->rc_override =
4616                 av_realloc(video_enc->rc_override,
4617                            sizeof(RcOverride) * (i + 1));
4618             video_enc->rc_override[i].start_frame = start;
4619             video_enc->rc_override[i].end_frame   = end;
4620             if (q > 0) {
4621                 video_enc->rc_override[i].qscale         = q;
4622                 video_enc->rc_override[i].quality_factor = 1.0;
4623             }
4624             else {
4625                 video_enc->rc_override[i].qscale         = 0;
4626                 video_enc->rc_override[i].quality_factor = -q/100.0;
4627             }
4628             p = strchr(p, '/');
4629             if (p) p++;
4630         }
4631         video_enc->rc_override_count = i;
4632         if (!video_enc->rc_initial_buffer_occupancy)
4633             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4634         video_enc->intra_dc_precision = intra_dc_precision - 8;
4635
4636         if (do_psnr)
4637             video_enc->flags|= CODEC_FLAG_PSNR;
4638
4639         /* two pass mode */
4640         if (do_pass) {
4641             if (do_pass & 1) {
4642                 video_enc->flags |= CODEC_FLAG_PASS1;
4643             }
4644             if (do_pass & 2) {
4645                 video_enc->flags |= CODEC_FLAG_PASS2;
4646             }
4647         }
4648
4649         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4650         if (forced_key_frames)
4651             parse_forced_key_frames(forced_key_frames, ost);
4652
4653         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4654
4655         ost->top_field_first = -1;
4656         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4657
4658         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4659         ost->avfilter = av_strdup(filters);
4660     } else {
4661         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4662     }
4663
4664     return ost;
4665 }
4666
4667 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4668 {
4669     int n;
4670     AVStream *st;
4671     OutputStream *ost;
4672     AVCodecContext *audio_enc;
4673
4674     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4675     st  = ost->st;
4676
4677     audio_enc = st->codec;
4678     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4679
4680     if (!ost->stream_copy) {
4681         char *sample_fmt = NULL;
4682         const char *filters = "anull";
4683
4684         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4685
4686         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4687         if (sample_fmt &&
4688             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4689             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4690             exit_program(1);
4691         }
4692
4693         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4694
4695         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4696
4697         av_assert1(filters);
4698         ost->avfilter = av_strdup(filters);
4699
4700         /* check for channel mapping for this audio stream */
4701         for (n = 0; n < o->nb_audio_channel_maps; n++) {
4702             AudioChannelMap *map = &o->audio_channel_maps[n];
4703             InputStream *ist = input_streams[ost->source_index];
4704             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4705                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
4706                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
4707                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4708                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4709                 else
4710                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4711                            ost->file_index, ost->st->index);
4712             }
4713         }
4714     }
4715
4716     return ost;
4717 }
4718
4719 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4720 {
4721     OutputStream *ost;
4722
4723     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4724     if (!ost->stream_copy) {
4725         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4726         exit_program(1);
4727     }
4728
4729     return ost;
4730 }
4731
4732 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4733 {
4734     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4735     ost->stream_copy = 1;
4736     return ost;
4737 }
4738
4739 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4740 {
4741     AVStream *st;
4742     OutputStream *ost;
4743     AVCodecContext *subtitle_enc;
4744
4745     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4746     st  = ost->st;
4747     subtitle_enc = st->codec;
4748
4749     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4750
4751     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4752
4753     return ost;
4754 }
4755
4756 /* arg format is "output-stream-index:streamid-value". */
4757 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4758 {
4759     int idx;
4760     char *p;
4761     char idx_str[16];
4762
4763     av_strlcpy(idx_str, arg, sizeof(idx_str));
4764     p = strchr(idx_str, ':');
4765     if (!p) {
4766         av_log(NULL, AV_LOG_FATAL,
4767                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4768                arg, opt);
4769         exit_program(1);
4770     }
4771     *p++ = '\0';
4772     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4773     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4774     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4775     return 0;
4776 }
4777
4778 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4779 {
4780     AVFormatContext *is = ifile->ctx;
4781     AVFormatContext *os = ofile->ctx;
4782     int i;
4783
4784     for (i = 0; i < is->nb_chapters; i++) {
4785         AVChapter *in_ch = is->chapters[i], *out_ch;
4786         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
4787                                        AV_TIME_BASE_Q, in_ch->time_base);
4788         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4789                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4790
4791
4792         if (in_ch->end < ts_off)
4793             continue;
4794         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4795             break;
4796
4797         out_ch = av_mallocz(sizeof(AVChapter));
4798         if (!out_ch)
4799             return AVERROR(ENOMEM);
4800
4801         out_ch->id        = in_ch->id;
4802         out_ch->time_base = in_ch->time_base;
4803         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
4804         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
4805
4806         if (copy_metadata)
4807             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4808
4809         os->nb_chapters++;
4810         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4811         if (!os->chapters)
4812             return AVERROR(ENOMEM);
4813         os->chapters[os->nb_chapters - 1] = out_ch;
4814     }
4815     return 0;
4816 }
4817
4818 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4819 {
4820     int i, err;
4821     AVFormatContext *ic = avformat_alloc_context();
4822
4823     ic->interrupt_callback = int_cb;
4824     err = avformat_open_input(&ic, filename, NULL, NULL);
4825     if (err < 0)
4826         return err;
4827     /* copy stream format */
4828     for(i=0;i<ic->nb_streams;i++) {
4829         AVStream *st;
4830         OutputStream *ost;
4831         AVCodec *codec;
4832         AVCodecContext *avctx;
4833
4834         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4835         ost   = new_output_stream(o, s, codec->type, -1);
4836         st    = ost->st;
4837         avctx = st->codec;
4838         ost->enc = codec;
4839
4840         // FIXME: a more elegant solution is needed
4841         memcpy(st, ic->streams[i], sizeof(AVStream));
4842         st->cur_dts = 0;
4843         st->info = av_malloc(sizeof(*st->info));
4844         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4845         st->codec= avctx;
4846         avcodec_copy_context(st->codec, ic->streams[i]->codec);
4847
4848         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4849             choose_sample_fmt(st, codec);
4850         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4851             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4852     }
4853
4854     avformat_close_input(&ic);
4855     return 0;
4856 }
4857
4858 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4859                                AVFormatContext *oc)
4860 {
4861     OutputStream *ost;
4862
4863     switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4864     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
4865     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
4866     default:
4867         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4868                "currently.\n");
4869         exit_program(1);
4870     }
4871
4872     ost->source_index = -1;
4873     ost->filter       = ofilter;
4874
4875     ofilter->ost      = ost;
4876
4877     if (ost->stream_copy) {
4878         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4879                "which is fed from a complex filtergraph. Filtering and streamcopy "
4880                "cannot be used together.\n", ost->file_index, ost->index);
4881         exit_program(1);
4882     }
4883
4884     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4885         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4886         exit_program(1);
4887     }
4888     avfilter_inout_free(&ofilter->out_tmp);
4889 }
4890
4891 static void opt_output_file(void *optctx, const char *filename)
4892 {
4893     OptionsContext *o = optctx;
4894     AVFormatContext *oc;
4895     int i, j, err;
4896     AVOutputFormat *file_oformat;
4897     OutputStream *ost;
4898     InputStream  *ist;
4899
4900     if (configure_complex_filters() < 0) {
4901         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4902         exit_program(1);
4903     }
4904
4905     if (!strcmp(filename, "-"))
4906         filename = "pipe:";
4907
4908     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4909     if (!oc) {
4910         print_error(filename, err);
4911         exit_program(1);
4912     }
4913     file_oformat= oc->oformat;
4914     oc->interrupt_callback = int_cb;
4915
4916     /* create streams for all unlabeled output pads */
4917     for (i = 0; i < nb_filtergraphs; i++) {
4918         FilterGraph *fg = filtergraphs[i];
4919         for (j = 0; j < fg->nb_outputs; j++) {
4920             OutputFilter *ofilter = fg->outputs[j];
4921
4922             if (!ofilter->out_tmp || ofilter->out_tmp->name)
4923                 continue;
4924
4925             switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4926             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
4927             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
4928             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4929             }
4930             init_output_filter(ofilter, o, oc);
4931         }
4932     }
4933
4934     if (!strcmp(file_oformat->name, "ffm") &&
4935         av_strstart(filename, "http:", NULL)) {
4936         int j;
4937         /* special case for files sent to ffserver: we get the stream
4938            parameters from ffserver */
4939         int err = read_ffserver_streams(o, oc, filename);
4940         if (err < 0) {
4941             print_error(filename, err);
4942             exit_program(1);
4943         }
4944         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4945             ost = output_streams[j];
4946             for (i = 0; i < nb_input_streams; i++) {
4947                 ist = input_streams[i];
4948                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4949                     ost->sync_ist= ist;
4950                     ost->source_index= i;
4951                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
4952                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
4953                     ist->discard = 0;
4954                     ist->st->discard = AVDISCARD_NONE;
4955                     break;
4956                 }
4957             }
4958             if(!ost->sync_ist){
4959                 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));
4960                 exit_program(1);
4961             }
4962         }
4963     } else if (!o->nb_stream_maps) {
4964         /* pick the "best" stream of each type */
4965
4966         /* video: highest resolution */
4967         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4968             int area = 0, idx = -1;
4969             for (i = 0; i < nb_input_streams; i++) {
4970                 ist = input_streams[i];
4971                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4972                     ist->st->codec->width * ist->st->codec->height > area) {
4973                     area = ist->st->codec->width * ist->st->codec->height;
4974                     idx = i;
4975                 }
4976             }
4977             if (idx >= 0)
4978                 new_video_stream(o, oc, idx);
4979         }
4980
4981         /* audio: most channels */
4982         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4983             int channels = 0, idx = -1;
4984             for (i = 0; i < nb_input_streams; i++) {
4985                 ist = input_streams[i];
4986                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4987                     ist->st->codec->channels > channels) {
4988                     channels = ist->st->codec->channels;
4989                     idx = i;
4990                 }
4991             }
4992             if (idx >= 0)
4993                 new_audio_stream(o, oc, idx);
4994         }
4995
4996         /* subtitles: pick first */
4997         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4998             for (i = 0; i < nb_input_streams; i++)
4999                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5000                     new_subtitle_stream(o, oc, i);
5001                     break;
5002                 }
5003         }
5004         /* do something with data? */
5005     } else {
5006         for (i = 0; i < o->nb_stream_maps; i++) {
5007             StreamMap *map = &o->stream_maps[i];
5008             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5009
5010             if (map->disabled)
5011                 continue;
5012
5013             if (map->linklabel) {
5014                 FilterGraph *fg;
5015                 OutputFilter *ofilter = NULL;
5016                 int j, k;
5017
5018                 for (j = 0; j < nb_filtergraphs; j++) {
5019                     fg = filtergraphs[j];
5020                     for (k = 0; k < fg->nb_outputs; k++) {
5021                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
5022                         if (out && !strcmp(out->name, map->linklabel)) {
5023                             ofilter = fg->outputs[k];
5024                             goto loop_end;
5025                         }
5026                     }
5027                 }
5028 loop_end:
5029                 if (!ofilter) {
5030                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5031                            "in any defined filter graph.\n", map->linklabel);
5032                     exit_program(1);
5033                 }
5034                 init_output_filter(ofilter, o, oc);
5035             } else {
5036                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5037                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5038                     continue;
5039                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5040                     continue;
5041                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5042                     continue;
5043                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5044                     continue;
5045
5046                 switch (ist->st->codec->codec_type) {
5047                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
5048                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
5049                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
5050                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
5051                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5052                 default:
5053                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5054                            map->file_index, map->stream_index);
5055                     exit_program(1);
5056                 }
5057             }
5058         }
5059     }
5060
5061
5062     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5063         AVDictionaryEntry *e;
5064         ost = output_streams[i];
5065
5066         if (   ost->stream_copy
5067             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5068             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5069             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5070                 exit_program(1);
5071     }
5072
5073     /* handle attached files */
5074     for (i = 0; i < o->nb_attachments; i++) {
5075         AVIOContext *pb;
5076         uint8_t *attachment;
5077         const char *p;
5078         int64_t len;
5079
5080         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5081             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5082                    o->attachments[i]);
5083             exit_program(1);
5084         }
5085         if ((len = avio_size(pb)) <= 0) {
5086             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5087                    o->attachments[i]);
5088             exit_program(1);
5089         }
5090         if (!(attachment = av_malloc(len))) {
5091             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5092                    o->attachments[i]);
5093             exit_program(1);
5094         }
5095         avio_read(pb, attachment, len);
5096
5097         ost = new_attachment_stream(o, oc, -1);
5098         ost->stream_copy               = 0;
5099         ost->attachment_filename       = o->attachments[i];
5100         ost->st->codec->extradata      = attachment;
5101         ost->st->codec->extradata_size = len;
5102
5103         p = strrchr(o->attachments[i], '/');
5104         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5105         avio_close(pb);
5106     }
5107
5108     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5109     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5110         exit_program(1);
5111
5112     output_files[nb_output_files - 1]->ctx            = oc;
5113     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
5114     output_files[nb_output_files - 1]->recording_time = o->recording_time;
5115     if (o->recording_time != INT64_MAX)
5116         oc->duration = o->recording_time;
5117     output_files[nb_output_files - 1]->start_time     = o->start_time;
5118     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5119     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5120
5121     /* check filename in case of an image number is expected */
5122     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5123         if (!av_filename_number_test(oc->filename)) {
5124             print_error(oc->filename, AVERROR(EINVAL));
5125             exit_program(1);
5126         }
5127     }
5128
5129     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5130         /* test if it already exists to avoid losing precious files */
5131         assert_file_overwrite(filename);
5132
5133         /* open the file */
5134         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5135                               &oc->interrupt_callback,
5136                               &output_files[nb_output_files - 1]->opts)) < 0) {
5137             print_error(filename, err);
5138             exit_program(1);
5139         }
5140     }
5141
5142     if (o->mux_preload) {
5143         uint8_t buf[64];
5144         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5145         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5146     }
5147     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5148
5149     /* copy metadata */
5150     for (i = 0; i < o->nb_metadata_map; i++) {
5151         char *p;
5152         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5153
5154         if (in_file_index >= nb_input_files) {
5155             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5156             exit_program(1);
5157         }
5158         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5159     }
5160
5161     /* copy chapters */
5162     if (o->chapters_input_file >= nb_input_files) {
5163         if (o->chapters_input_file == INT_MAX) {
5164             /* copy chapters from the first input file that has them*/
5165             o->chapters_input_file = -1;
5166             for (i = 0; i < nb_input_files; i++)
5167                 if (input_files[i]->ctx->nb_chapters) {
5168                     o->chapters_input_file = i;
5169                     break;
5170                 }
5171         } else {
5172             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5173                    o->chapters_input_file);
5174             exit_program(1);
5175         }
5176     }
5177     if (o->chapters_input_file >= 0)
5178         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5179                       !o->metadata_chapters_manual);
5180
5181     /* copy global metadata by default */
5182     if (!o->metadata_global_manual && nb_input_files){
5183         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5184                      AV_DICT_DONT_OVERWRITE);
5185         if(o->recording_time != INT64_MAX)
5186             av_dict_set(&oc->metadata, "duration", NULL, 0);
5187     }
5188     if (!o->metadata_streams_manual)
5189         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5190             InputStream *ist;
5191             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
5192                 continue;
5193             ist = input_streams[output_streams[i]->source_index];
5194             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5195         }
5196
5197     /* process manually set metadata */
5198     for (i = 0; i < o->nb_metadata; i++) {
5199         AVDictionary **m;
5200         char type, *val;
5201         const char *stream_spec;
5202         int index = 0, j, ret = 0;
5203
5204         val = strchr(o->metadata[i].u.str, '=');
5205         if (!val) {
5206             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5207                    o->metadata[i].u.str);
5208             exit_program(1);
5209         }
5210         *val++ = 0;
5211
5212         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5213         if (type == 's') {
5214             for (j = 0; j < oc->nb_streams; j++) {
5215                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5216                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5217                 } else if (ret < 0)
5218                     exit_program(1);
5219             }
5220             printf("ret %d, stream_spec %s\n", ret, stream_spec);
5221         }
5222         else {
5223             switch (type) {
5224             case 'g':
5225                 m = &oc->metadata;
5226                 break;
5227             case 'c':
5228                 if (index < 0 || index >= oc->nb_chapters) {
5229                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5230                     exit_program(1);
5231                 }
5232                 m = &oc->chapters[index]->metadata;
5233                 break;
5234             default:
5235                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5236                 exit_program(1);
5237             }
5238             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5239         }
5240     }
5241
5242     reset_options(o, 0);
5243 }
5244
5245 /* same option as mencoder */
5246 static int opt_pass(const char *opt, const char *arg)
5247 {
5248     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5249     return 0;
5250 }
5251
5252 static int64_t getmaxrss(void)
5253 {
5254 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5255     struct rusage rusage;
5256     getrusage(RUSAGE_SELF, &rusage);
5257     return (int64_t)rusage.ru_maxrss * 1024;
5258 #elif HAVE_GETPROCESSMEMORYINFO
5259     HANDLE proc;
5260     PROCESS_MEMORY_COUNTERS memcounters;
5261     proc = GetCurrentProcess();
5262     memcounters.cb = sizeof(memcounters);
5263     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5264     return memcounters.PeakPagefileUsage;
5265 #else
5266     return 0;
5267 #endif
5268 }
5269
5270 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5271 {
5272     return parse_option(o, "q:a", arg, options);
5273 }
5274
5275 static void show_usage(void)
5276 {
5277     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5278     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5279     av_log(NULL, AV_LOG_INFO, "\n");
5280 }
5281
5282 static int opt_help(const char *opt, const char *arg)
5283 {
5284     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5285     av_log_set_callback(log_callback_help);
5286     show_usage();
5287     show_help_options(options, "Main options:\n",
5288                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5289     show_help_options(options, "\nAdvanced options:\n",
5290                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5291                       OPT_EXPERT);
5292     show_help_options(options, "\nVideo options:\n",
5293                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5294                       OPT_VIDEO);
5295     show_help_options(options, "\nAdvanced Video options:\n",
5296                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5297                       OPT_VIDEO | OPT_EXPERT);
5298     show_help_options(options, "\nAudio options:\n",
5299                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5300                       OPT_AUDIO);
5301     show_help_options(options, "\nAdvanced Audio options:\n",
5302                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5303                       OPT_AUDIO | OPT_EXPERT);
5304     show_help_options(options, "\nSubtitle options:\n",
5305                       OPT_SUBTITLE | OPT_GRAB,
5306                       OPT_SUBTITLE);
5307     show_help_options(options, "\nAudio/Video grab options:\n",
5308                       OPT_GRAB,
5309                       OPT_GRAB);
5310     printf("\n");
5311     show_help_children(avcodec_get_class(), flags);
5312     show_help_children(avformat_get_class(), flags);
5313     show_help_children(sws_get_class(), flags);
5314
5315     return 0;
5316 }
5317
5318 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5319 {
5320     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5321     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5322
5323     if (!strncmp(arg, "pal-", 4)) {
5324         norm = PAL;
5325         arg += 4;
5326     } else if (!strncmp(arg, "ntsc-", 5)) {
5327         norm = NTSC;
5328         arg += 5;
5329     } else if (!strncmp(arg, "film-", 5)) {
5330         norm = FILM;
5331         arg += 5;
5332     } else {
5333         /* Try to determine PAL/NTSC by peeking in the input files */
5334         if (nb_input_files) {
5335             int i, j, fr;
5336             for (j = 0; j < nb_input_files; j++) {
5337                 for (i = 0; i < input_files[j]->nb_streams; i++) {
5338                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5339                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5340                         continue;
5341                     fr = c->time_base.den * 1000 / c->time_base.num;
5342                     if (fr == 25000) {
5343                         norm = PAL;
5344                         break;
5345                     } else if ((fr == 29970) || (fr == 23976)) {
5346                         norm = NTSC;
5347                         break;
5348                     }
5349                 }
5350                 if (norm != UNKNOWN)
5351                     break;
5352             }
5353         }
5354         if (norm != UNKNOWN)
5355             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5356     }
5357
5358     if (norm == UNKNOWN) {
5359         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5360         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5361         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5362         exit_program(1);
5363     }
5364
5365     if (!strcmp(arg, "vcd")) {
5366         opt_video_codec(o, "c:v", "mpeg1video");
5367         opt_audio_codec(o, "c:a", "mp2");
5368         parse_option(o, "f", "vcd", options);
5369
5370         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5371         parse_option(o, "r", frame_rates[norm], options);
5372         opt_default("g", norm == PAL ? "15" : "18");
5373
5374         opt_default("b:v", "1150000");
5375         opt_default("maxrate", "1150000");
5376         opt_default("minrate", "1150000");
5377         opt_default("bufsize", "327680"); // 40*1024*8;
5378
5379         opt_default("b:a", "224000");
5380         parse_option(o, "ar", "44100", options);
5381         parse_option(o, "ac", "2", options);
5382
5383         opt_default("packetsize", "2324");
5384         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5385
5386         /* We have to offset the PTS, so that it is consistent with the SCR.
5387            SCR starts at 36000, but the first two packs contain only padding
5388            and the first pack from the other stream, respectively, may also have
5389            been written before.
5390            So the real data starts at SCR 36000+3*1200. */
5391         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5392     } else if (!strcmp(arg, "svcd")) {
5393
5394         opt_video_codec(o, "c:v", "mpeg2video");
5395         opt_audio_codec(o, "c:a", "mp2");
5396         parse_option(o, "f", "svcd", options);
5397
5398         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5399         parse_option(o, "r", frame_rates[norm], options);
5400         parse_option(o, "pix_fmt", "yuv420p", options);
5401         opt_default("g", norm == PAL ? "15" : "18");
5402
5403         opt_default("b:v", "2040000");
5404         opt_default("maxrate", "2516000");
5405         opt_default("minrate", "0"); // 1145000;
5406         opt_default("bufsize", "1835008"); // 224*1024*8;
5407         opt_default("scan_offset", "1");
5408
5409
5410         opt_default("b:a", "224000");
5411         parse_option(o, "ar", "44100", options);
5412
5413         opt_default("packetsize", "2324");
5414
5415     } else if (!strcmp(arg, "dvd")) {
5416
5417         opt_video_codec(o, "c:v", "mpeg2video");
5418         opt_audio_codec(o, "c:a", "ac3");
5419         parse_option(o, "f", "dvd", options);
5420
5421         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5422         parse_option(o, "r", frame_rates[norm], options);
5423         parse_option(o, "pix_fmt", "yuv420p", options);
5424         opt_default("g", norm == PAL ? "15" : "18");
5425
5426         opt_default("b:v", "6000000");
5427         opt_default("maxrate", "9000000");
5428         opt_default("minrate", "0"); // 1500000;
5429         opt_default("bufsize", "1835008"); // 224*1024*8;
5430
5431         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5432         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5433
5434         opt_default("b:a", "448000");
5435         parse_option(o, "ar", "48000", options);
5436
5437     } else if (!strncmp(arg, "dv", 2)) {
5438
5439         parse_option(o, "f", "dv", options);
5440
5441         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5442         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5443                           norm == PAL ? "yuv420p" : "yuv411p", options);
5444         parse_option(o, "r", frame_rates[norm], options);
5445
5446         parse_option(o, "ar", "48000", options);
5447         parse_option(o, "ac", "2", options);
5448
5449     } else {
5450         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5451         return AVERROR(EINVAL);
5452     }
5453     return 0;
5454 }
5455
5456 static int opt_vstats_file(const char *opt, const char *arg)
5457 {
5458     av_free (vstats_filename);
5459     vstats_filename = av_strdup (arg);
5460     return 0;
5461 }
5462
5463 static int opt_vstats(const char *opt, const char *arg)
5464 {
5465     char filename[40];
5466     time_t today2 = time(NULL);
5467     struct tm *today = localtime(&today2);
5468
5469     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5470              today->tm_sec);
5471     return opt_vstats_file(opt, filename);
5472 }
5473
5474 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5475 {
5476     return parse_option(o, "frames:v", arg, options);
5477 }
5478
5479 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5480 {
5481     return parse_option(o, "frames:a", arg, options);
5482 }
5483
5484 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5485 {
5486     return parse_option(o, "frames:d", arg, options);
5487 }
5488
5489 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5490 {
5491     FILE *f=NULL;
5492     char filename[1000], line[1000], tmp_line[1000];
5493     const char *codec_name = *opt == 'v' ? video_codec_name :
5494                              *opt == 'a' ? audio_codec_name :
5495                                            subtitle_codec_name;
5496
5497     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5498         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5499             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5500         }else
5501             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5502         exit_program(1);
5503     }
5504
5505     while (fgets(line, sizeof(line), f)) {
5506         char *key = tmp_line, *value, *endptr;
5507
5508         if (strcspn(line, "#\n\r") == 0)
5509             continue;
5510         strcpy(tmp_line, line);
5511         if (!av_strtok(key,   "=",    &value) ||
5512             !av_strtok(value, "\r\n", &endptr)) {
5513             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5514             exit_program(1);
5515         }
5516         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5517
5518         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
5519         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
5520         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5521         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
5522         else if (opt_default(key, value) < 0) {
5523             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5524                    filename, line, key, value);
5525             exit_program(1);
5526         }
5527     }
5528
5529     fclose(f);
5530
5531     return 0;
5532 }
5533
5534 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5535 {
5536 }
5537
5538 static int opt_passlogfile(const char *opt, const char *arg)
5539 {
5540     pass_logfilename_prefix = arg;
5541 #if CONFIG_LIBX264_ENCODER
5542     return opt_default(opt, arg);
5543 #else
5544     return 0;
5545 #endif
5546 }
5547
5548 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5549 {
5550     char *s = av_asprintf("%s:%c", opt + 1, *opt);
5551     int ret = parse_option(o, s, arg, options);
5552     av_free(s);
5553     return ret;
5554 }
5555
5556 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5557 {
5558     if(!strcmp(opt, "b")){
5559         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5560         return parse_option(o, "b:v", arg, options);
5561     }
5562     return opt_default(opt, arg);
5563 }
5564
5565 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5566 {
5567     char *s;
5568     int ret;
5569     if(!strcmp(opt, "qscale")){
5570         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5571         return parse_option(o, "q:v", arg, options);
5572     }
5573     s = av_asprintf("q%s", opt + 6);
5574     ret = parse_option(o, s, arg, options);
5575     av_free(s);
5576     return ret;
5577 }
5578
5579 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5580 {
5581     if(!strcmp(opt, "profile")){
5582         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5583         return parse_option(o, "profile:v", arg, options);
5584     }
5585     return opt_default(opt, arg);
5586 }
5587
5588 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5589 {
5590     return parse_option(o, "filter:v", arg, options);
5591 }
5592
5593 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5594 {
5595     return parse_option(o, "filter:a", arg, options);
5596 }
5597
5598 static int opt_vsync(const char *opt, const char *arg)
5599 {
5600     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
5601     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
5602     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5603     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
5604
5605     if (video_sync_method == VSYNC_AUTO)
5606         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5607     return 0;
5608 }
5609
5610 static int opt_deinterlace(const char *opt, const char *arg)
5611 {
5612     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5613     do_deinterlace = 1;
5614     return 0;
5615 }
5616
5617 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5618 {
5619     int idx = locate_option(argc, argv, options, "cpuflags");
5620     if (idx && argv[idx + 1])
5621         opt_cpuflags("cpuflags", argv[idx + 1]);
5622 }
5623
5624 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5625 {
5626     char layout_str[32];
5627     char *stream_str;
5628     char *ac_str;
5629     int ret, channels, ac_str_size;
5630     uint64_t layout;
5631
5632     layout = av_get_channel_layout(arg);
5633     if (!layout) {
5634         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5635         return AVERROR(EINVAL);
5636     }
5637     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5638     ret = opt_default(opt, layout_str);
5639     if (ret < 0)
5640         return ret;
5641
5642     /* set 'ac' option based on channel layout */
5643     channels = av_get_channel_layout_nb_channels(layout);
5644     snprintf(layout_str, sizeof(layout_str), "%d", channels);
5645     stream_str = strchr(opt, ':');
5646     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5647     ac_str = av_mallocz(ac_str_size);
5648     if (!ac_str)
5649         return AVERROR(ENOMEM);
5650     av_strlcpy(ac_str, "ac", 3);
5651     if (stream_str)
5652         av_strlcat(ac_str, stream_str, ac_str_size);
5653     ret = parse_option(o, ac_str, layout_str, options);
5654     av_free(ac_str);
5655
5656     return ret;
5657 }
5658
5659 static int opt_filter_complex(const char *opt, const char *arg)
5660 {
5661     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5662                               &nb_filtergraphs, nb_filtergraphs + 1);
5663     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5664         return AVERROR(ENOMEM);
5665     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
5666     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5667     return 0;
5668 }
5669
5670 #define OFFSET(x) offsetof(OptionsContext, x)
5671 static const OptionDef options[] = {
5672     /* main options */
5673 #include "cmdutils_common_opts.h"
5674     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5675     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5676     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5677     { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5678     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5679     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5680     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5681     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5682     { "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]" },
5683     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5684       "outfile[,metadata]:infile[,metadata]" },
5685     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
5686     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5687     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5688     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5689     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5690     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5691     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5692     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5693     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5694     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5695       "add timings for benchmarking" },
5696     { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5697       "add timings for each task" },
5698     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5699     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5700       "dump each input packet" },
5701     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5702       "when dumping packets, also dump the payload" },
5703     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5704     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5705     { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5706     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5707     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5708     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
5709     { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying", "mode" },
5710     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5711     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5712     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5713     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5714     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5715     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5716     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5717     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5718     { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5719     { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5720     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5721     { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5722     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5723     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5724     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5725     { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5726
5727     /* video options */
5728     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5729     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5730     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5731     { "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" },
5732     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5733     { "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" },
5734     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5735     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5736     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5737     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5738     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5739     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5740     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5741     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5742     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5743     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5744     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5745     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5746     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5747     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5748     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5749     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5750       "use same quantizer as source (implies VBR)" },
5751     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5752     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5753     { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5754       "this option is deprecated, use the yadif filter instead" },
5755     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5756     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5757     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5758     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5759     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5760     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5761     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5762     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5763     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5764     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5765     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5766     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5767     { "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" },
5768     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5769
5770     /* audio options */
5771     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5772     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5773     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5774     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5775     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5776     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5777     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5778     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5779     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5780     { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5781     { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
5782
5783     /* subtitle options */
5784     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5785     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5786     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5787
5788     /* grab options */
5789     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5790     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5791     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5792
5793     /* muxer options */
5794     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5795     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
5796
5797     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5798     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5799     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5800
5801     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5802     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5803     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5804     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5805     /* data codec support */
5806     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5807     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5808
5809     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5810     { NULL, },
5811 };
5812
5813 int main(int argc, char **argv)
5814 {
5815     OptionsContext o = { 0 };
5816     int64_t ti;
5817
5818     reset_options(&o, 0);
5819
5820     av_log_set_flags(AV_LOG_SKIP_REPEATED);
5821     parse_loglevel(argc, argv, options);
5822
5823     if(argc>1 && !strcmp(argv[1], "-d")){
5824         run_as_daemon=1;
5825         av_log_set_callback(log_callback_null);
5826         argc--;
5827         argv++;
5828     }
5829
5830     avcodec_register_all();
5831 #if CONFIG_AVDEVICE
5832     avdevice_register_all();
5833 #endif
5834     avfilter_register_all();
5835     av_register_all();
5836     avformat_network_init();
5837
5838     show_banner(argc, argv, options);
5839
5840     term_init();
5841
5842     parse_cpuflags(argc, argv, options);
5843
5844     /* parse options */
5845     parse_options(&o, argc, argv, options, opt_output_file);
5846
5847     if (nb_output_files <= 0 && nb_input_files == 0) {
5848         show_usage();
5849         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5850         exit_program(1);
5851     }
5852
5853     /* file converter / grab */
5854     if (nb_output_files <= 0) {
5855         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5856         exit_program(1);
5857     }
5858
5859     if (nb_input_files == 0) {
5860         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5861         exit_program(1);
5862     }
5863
5864     current_time = ti = getutime();
5865     if (transcode() < 0)
5866         exit_program(1);
5867     ti = getutime() - ti;
5868     if (do_benchmark) {
5869         int maxrss = getmaxrss() / 1024;
5870         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
5871     }
5872
5873     exit_program(0);
5874     return 0;
5875 }