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