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