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

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