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

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