git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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