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

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