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

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