ffmpeg_opt.c 136 KB
Newer Older
1
/*
2
 * ffmpeg option parsing
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7 8 9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12 13 14 15 16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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 19 20 21 22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdint.h>

23
#include "ffmpeg.h"
24 25 26 27 28 29 30 31 32 33 34
#include "cmdutils.h"

#include "libavformat/avformat.h"

#include "libavcodec/avcodec.h"

#include "libavfilter/avfilter.h"

#include "libavutil/avassert.h"
#include "libavutil/avstring.h"
#include "libavutil/avutil.h"
35
#include "libavutil/channel_layout.h"
36 37 38 39 40 41 42 43
#include "libavutil/intreadwrite.h"
#include "libavutil/fifo.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
#include "libavutil/pixdesc.h"
#include "libavutil/pixfmt.h"

44
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
45

46 47 48 49 50 51 52 53
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
{\
    int i, ret;\
    for (i = 0; i < o->nb_ ## name; i++) {\
        char *spec = o->name[i].specifier;\
        if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
            outvar = o->name[i].u.type;\
        else if (ret < 0)\
54
            exit_program(1);\
55 56 57
    }\
}

58 59
#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
{\
60
    int i;\
61 62
    for (i = 0; i < o->nb_ ## name; i++) {\
        char *spec = o->name[i].specifier;\
63
        if (!strcmp(spec, mediatype))\
64 65 66
            outvar = o->name[i].u.type;\
    }\
}
67

68
const HWAccel hwaccels[] = {
69 70
#if HAVE_VDPAU_X11
    { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71
#endif
72
#if HAVE_DXVA2_LIB
73
    { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 75
#endif
#if CONFIG_VDA
76 77 78 79
    { "vda",   videotoolbox_init,   HWACCEL_VDA,   AV_PIX_FMT_VDA },
#endif
#if CONFIG_VIDEOTOOLBOX
    { "videotoolbox",   videotoolbox_init,   HWACCEL_VIDEOTOOLBOX,   AV_PIX_FMT_VIDEOTOOLBOX },
80 81 82
#endif
#if CONFIG_LIBMFX
    { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV },
83 84 85
#endif
#if CONFIG_VAAPI
    { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
86 87 88
#endif
#if CONFIG_CUVID
    { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
89
#endif
90 91
    { 0 },
};
92 93
int hwaccel_lax_profile_check = 0;
AVBufferRef *hw_device_ctx;
94

95
char *vstats_filename;
96
char *sdp_filename;
97 98 99

float audio_drift_threshold = 0.1;
float dts_delta_threshold   = 10;
100
float dts_error_threshold   = 3600*30;
101 102 103 104

int audio_volume      = 256;
int audio_sync_method = 0;
int video_sync_method = VSYNC_AUTO;
105
float frame_drop_threshold = 0;
106 107
int do_deinterlace    = 0;
int do_benchmark      = 0;
108
int do_benchmark_all  = 0;
109 110 111
int do_hex_dump       = 0;
int do_pkt_dump       = 0;
int copy_ts           = 0;
112
int start_at_zero     = 0;
113 114
int copy_tb           = -1;
int debug_ts          = 0;
115
int exit_on_error     = 0;
116
int abort_on_flags    = 0;
117
int print_stats       = -1;
118
int qp_hist           = 0;
119 120
int stdin_interaction = 1;
int frame_bits_per_raw_sample = 0;
121
float max_error_rate  = 2.0/3;
122

123 124

static int intra_only         = 0;
125
static int file_overwrite     = 0;
126 127
static int no_file_overwrite  = 0;
static int do_psnr            = 0;
128
static int input_sync;
129
static int override_ffserver  = 0;
130
static int input_stream_potentially_available = 0;
131
static int ignore_unknown_streams = 0;
132
static int copy_unknown_streams = 0;
133

134
static void uninit_options(OptionsContext *o)
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
{
    const OptionDef *po = options;
    int i;

    /* all OPT_SPEC and OPT_STRING can be freed in generic way */
    while (po->name) {
        void *dst = (uint8_t*)o + po->u.off;

        if (po->flags & OPT_SPEC) {
            SpecifierOpt **so = dst;
            int i, *count = (int*)(so + 1);
            for (i = 0; i < *count; i++) {
                av_freep(&(*so)[i].specifier);
                if (po->flags & OPT_STRING)
                    av_freep(&(*so)[i].u.str);
            }
            av_freep(so);
            *count = 0;
        } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
            av_freep(dst);
        po++;
    }

    for (i = 0; i < o->nb_stream_maps; i++)
        av_freep(&o->stream_maps[i].linklabel);
    av_freep(&o->stream_maps);
161
    av_freep(&o->audio_channel_maps);
162
    av_freep(&o->streamid_map);
163
    av_freep(&o->attachments);
164
}
165

166
static void init_options(OptionsContext *o)
167
{
168 169
    memset(o, 0, sizeof(*o));

170
    o->stop_time = INT64_MAX;
171
    o->mux_max_delay  = 0.7;
172
    o->start_time     = AV_NOPTS_VALUE;
173
    o->start_time_eof = AV_NOPTS_VALUE;
174
    o->recording_time = INT64_MAX;
175 176
    o->limit_filesize = UINT64_MAX;
    o->chapters_input_file = INT_MAX;
177
    o->accurate_seek  = 1;
178 179
}

180 181 182 183 184 185 186 187 188 189 190 191
static int show_hwaccels(void *optctx, const char *opt, const char *arg)
{
    int i;

    printf("Hardware acceleration methods:\n");
    for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
        printf("%s\n", hwaccels[i].name);
    }
    printf("\n");
    return 0;
}

192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
/* return a copy of the input with the stream specifiers removed from the keys */
static AVDictionary *strip_specifiers(AVDictionary *dict)
{
    AVDictionaryEntry *e = NULL;
    AVDictionary    *ret = NULL;

    while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
        char *p = strchr(e->key, ':');

        if (p)
            *p = 0;
        av_dict_set(&ret, e->key, e->value, 0);
        if (p)
            *p = ':';
    }
    return ret;
}

210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
static int opt_abort_on(void *optctx, const char *opt, const char *arg)
{
    static const AVOption opts[] = {
        { "abort_on"        , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
        { "empty_output"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT     },    .unit = "flags" },
        { NULL },
    };
    static const AVClass class = {
        .class_name = "",
        .item_name  = av_default_item_name,
        .option     = opts,
        .version    = LIBAVUTIL_VERSION_INT,
    };
    const AVClass *pclass = &class;

    return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
}

228 229
static int opt_sameq(void *optctx, const char *opt, const char *arg)
{
230 231 232 233 234
    av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
           "If you are looking for an option to preserve the quality (which is not "
           "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
           opt, opt);
    return AVERROR(EINVAL);
235 236
}

237
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
238 239
{
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
240
    return opt_default(optctx, "channel", arg);
241
}
242

243
static int opt_video_standard(void *optctx, const char *opt, const char *arg)
244 245
{
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
246
    return opt_default(optctx, "standard", arg);
247 248
}

249
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
250
{
251
    OptionsContext *o = optctx;
252 253 254
    return parse_option(o, "codec:a", arg, options);
}

255
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
256
{
257
    OptionsContext *o = optctx;
258 259 260
    return parse_option(o, "codec:v", arg, options);
}

261
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
262
{
263
    OptionsContext *o = optctx;
264 265 266
    return parse_option(o, "codec:s", arg, options);
}

267
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
268
{
269
    OptionsContext *o = optctx;
270 271 272
    return parse_option(o, "codec:d", arg, options);
}

273
static int opt_map(void *optctx, const char *opt, const char *arg)
274
{
275
    OptionsContext *o = optctx;
276 277
    StreamMap *m = NULL;
    int i, negative = 0, file_idx;
278
    int sync_file_idx = -1, sync_stream_idx = 0;
279 280
    char *p, *sync;
    char *map;
281
    char *allow_unused;
282 283 284 285 286 287

    if (*arg == '-') {
        negative = 1;
        arg++;
    }
    map = av_strdup(arg);
288 289
    if (!map)
        return AVERROR(ENOMEM);
290 291 292 293 294 295 296

    /* parse sync stream first, just pick first matching stream */
    if (sync = strchr(map, ',')) {
        *sync = 0;
        sync_file_idx = strtol(sync + 1, &sync, 0);
        if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
            av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
297
            exit_program(1);
298 299 300 301 302 303 304 305 306 307 308 309
        }
        if (*sync)
            sync++;
        for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
            if (check_stream_specifier(input_files[sync_file_idx]->ctx,
                                       input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
                sync_stream_idx = i;
                break;
            }
        if (i == input_files[sync_file_idx]->nb_streams) {
            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
                                       "match any streams.\n", arg);
310
            exit_program(1);
311 312 313 314 315 316 317
        }
    }


    if (map[0] == '[') {
        /* this mapping refers to lavfi output */
        const char *c = map + 1;
318
        GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
319 320 321 322
        m = &o->stream_maps[o->nb_stream_maps - 1];
        m->linklabel = av_get_token(&c, "]");
        if (!m->linklabel) {
            av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
323
            exit_program(1);
324 325
        }
    } else {
326 327
        if (allow_unused = strchr(map, '?'))
            *allow_unused = 0;
328 329 330
        file_idx = strtol(map, &p, 0);
        if (file_idx >= nb_input_files || file_idx < 0) {
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
331
            exit_program(1);
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
        }
        if (negative)
            /* disable some already defined maps */
            for (i = 0; i < o->nb_stream_maps; i++) {
                m = &o->stream_maps[i];
                if (file_idx == m->file_index &&
                    check_stream_specifier(input_files[m->file_index]->ctx,
                                           input_files[m->file_index]->ctx->streams[m->stream_index],
                                           *p == ':' ? p + 1 : p) > 0)
                    m->disabled = 1;
            }
        else
            for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
                if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
                            *p == ':' ? p + 1 : p) <= 0)
                    continue;
348
                GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
                m = &o->stream_maps[o->nb_stream_maps - 1];

                m->file_index   = file_idx;
                m->stream_index = i;

                if (sync_file_idx >= 0) {
                    m->sync_file_index   = sync_file_idx;
                    m->sync_stream_index = sync_stream_idx;
                } else {
                    m->sync_file_index   = file_idx;
                    m->sync_stream_index = i;
                }
            }
    }

    if (!m) {
365 366 367 368 369 370 371
        if (allow_unused) {
            av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
        } else {
            av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
                                       "To ignore this, add a trailing '?' to the map.\n", arg);
            exit_program(1);
        }
372 373 374 375 376 377
    }

    av_freep(&map);
    return 0;
}

378
static int opt_attach(void *optctx, const char *opt, const char *arg)
379
{
380
    OptionsContext *o = optctx;
381
    GROW_ARRAY(o->attachments, o->nb_attachments);
382 383 384 385
    o->attachments[o->nb_attachments - 1] = arg;
    return 0;
}

386
static int opt_map_channel(void *optctx, const char *opt, const char *arg)
387
{
388
    OptionsContext *o = optctx;
389 390 391 392
    int n;
    AVStream *st;
    AudioChannelMap *m;

393
    GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
    m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];

    /* muted channel syntax */
    n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
    if ((n == 1 || n == 3) && m->channel_idx == -1) {
        m->file_idx = m->stream_idx = -1;
        if (n == 1)
            m->ofile_idx = m->ostream_idx = -1;
        return 0;
    }

    /* normal syntax */
    n = sscanf(arg, "%d.%d.%d:%d.%d",
               &m->file_idx,  &m->stream_idx, &m->channel_idx,
               &m->ofile_idx, &m->ostream_idx);

    if (n != 3 && n != 5) {
        av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
               "[file.stream.channel|-1][:syncfile:syncstream]\n");
413
        exit_program(1);
414 415 416 417 418 419 420 421 422
    }

    if (n != 5) // only file.stream.channel specified
        m->ofile_idx = m->ostream_idx = -1;

    /* check input */
    if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
               m->file_idx);
423
        exit_program(1);
424 425 426 427 428
    }
    if (m->stream_idx < 0 ||
        m->stream_idx >= input_files[m->file_idx]->nb_streams) {
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
               m->file_idx, m->stream_idx);
429
        exit_program(1);
430 431 432 433 434
    }
    st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
    if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
        av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
               m->file_idx, m->stream_idx);
435
        exit_program(1);
436 437 438 439
    }
    if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
               m->file_idx, m->stream_idx, m->channel_idx);
440
        exit_program(1);
441 442 443 444
    }
    return 0;
}

445 446 447 448 449 450 451
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
{
    av_free(sdp_filename);
    sdp_filename = av_strdup(arg);
    return 0;
}

452 453 454 455 456 457 458 459 460 461 462
#if CONFIG_VAAPI
static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
{
    int err;
    err = vaapi_device_init(arg);
    if (err < 0)
        exit_program(1);
    return 0;
}
#endif

463
/**
464
 * Parse a metadata specifier passed as 'arg' parameter.
465
 * @param arg  metadata string to parse
466 467 468 469 470 471 472 473 474 475 476 477 478 479
 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
 * @param index for type c/p, chapter/program index is written here
 * @param stream_spec for type s, the stream specifier is written here
 */
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
{
    if (*arg) {
        *type = *arg;
        switch (*arg) {
        case 'g':
            break;
        case 's':
            if (*(++arg) && *arg != ':') {
                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
480
                exit_program(1);
481 482 483 484 485 486 487 488 489 490
            }
            *stream_spec = *arg == ':' ? arg + 1 : "";
            break;
        case 'c':
        case 'p':
            if (*(++arg) == ':')
                *index = strtol(++arg, NULL, 0);
            break;
        default:
            av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
491
            exit_program(1);
492 493 494 495 496 497 498 499
        }
    } else
        *type = 'g';
}

static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
{
    AVDictionary **meta_in = NULL;
500
    AVDictionary **meta_out = NULL;
501 502 503 504 505 506 507 508
    int i, ret = 0;
    char type_in, type_out;
    const char *istream_spec = NULL, *ostream_spec = NULL;
    int idx_in = 0, idx_out = 0;

    parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
    parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);

509 510 511 512 513 514 515 516 517 518
    if (!ic) {
        if (type_out == 'g' || !*outspec)
            o->metadata_global_manual = 1;
        if (type_out == 's' || !*outspec)
            o->metadata_streams_manual = 1;
        if (type_out == 'c' || !*outspec)
            o->metadata_chapters_manual = 1;
        return 0;
    }

519 520 521 522 523 524 525
    if (type_in == 'g' || type_out == 'g')
        o->metadata_global_manual = 1;
    if (type_in == 's' || type_out == 's')
        o->metadata_streams_manual = 1;
    if (type_in == 'c' || type_out == 'c')
        o->metadata_chapters_manual = 1;

526 527 528 529
    /* ic is NULL when just disabling automatic mappings */
    if (!ic)
        return 0;

530 531 532 533
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
    if ((index) < 0 || (index) >= (nb_elems)) {\
        av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
                (desc), (index));\
534
        exit_program(1);\
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
    }

#define SET_DICT(type, meta, context, index)\
        switch (type) {\
        case 'g':\
            meta = &context->metadata;\
            break;\
        case 'c':\
            METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
            meta = &context->chapters[index]->metadata;\
            break;\
        case 'p':\
            METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
            meta = &context->programs[index]->metadata;\
            break;\
550
        case 's':\
551
            break; /* handled separately below */ \
552 553 554 555 556 557 558 559 560 561 562 563 564
        default: av_assert0(0);\
        }\

    SET_DICT(type_in, meta_in, ic, idx_in);
    SET_DICT(type_out, meta_out, oc, idx_out);

    /* for input streams choose first matching stream */
    if (type_in == 's') {
        for (i = 0; i < ic->nb_streams; i++) {
            if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
                meta_in = &ic->streams[i]->metadata;
                break;
            } else if (ret < 0)
565
                exit_program(1);
566 567 568
        }
        if (!meta_in) {
            av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
569
            exit_program(1);
570 571 572 573 574 575 576 577 578
        }
    }

    if (type_out == 's') {
        for (i = 0; i < oc->nb_streams; i++) {
            if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
                meta_out = &oc->streams[i]->metadata;
                av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
            } else if (ret < 0)
579
                exit_program(1);
580 581 582 583 584 585 586
        }
    } else
        av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);

    return 0;
}

587
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
588
{
589
    OptionsContext *o = optctx;
590 591 592
    char buf[128];
    int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
    struct tm time = *gmtime((time_t*)&recording_timestamp);
593
    if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
594
        return -1;
595 596 597 598 599 600 601
    parse_option(o, "metadata", buf, options);

    av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
                                 "tag instead.\n", opt);
    return 0;
}

602 603
static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
{
604
    const AVCodecDescriptor *desc;
605 606 607 608 609 610
    const char *codec_string = encoder ? "encoder" : "decoder";
    AVCodec *codec;

    codec = encoder ?
        avcodec_find_encoder_by_name(name) :
        avcodec_find_decoder_by_name(name);
611 612 613 614 615 616 617 618 619

    if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
        codec = encoder ? avcodec_find_encoder(desc->id) :
                          avcodec_find_decoder(desc->id);
        if (codec)
            av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
                   codec_string, codec->name, desc->name);
    }

620 621
    if (!codec) {
        av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
622
        exit_program(1);
623 624 625
    }
    if (codec->type != type) {
        av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
626
        exit_program(1);
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
    }
    return codec;
}

static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
{
    char *codec_name = NULL;

    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
    if (codec_name) {
        AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
        st->codec->codec_id = codec->id;
        return codec;
    } else
        return avcodec_find_decoder(st->codec->codec_id);
}

644 645
/* Add all the streams from the given input file to the global
 * list of input streams. */
646 647
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
{
648
    int i, ret;
649 650 651 652 653

    for (i = 0; i < ic->nb_streams; i++) {
        AVStream *st = ic->streams[i];
        AVCodecContext *dec = st->codec;
        InputStream *ist = av_mallocz(sizeof(*ist));
654
        char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
655
        char *hwaccel_output_format = NULL;
656 657
        char *codec_tag = NULL;
        char *next;
658 659
        char *discard_str = NULL;
        const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
660 661

        if (!ist)
662
            exit_program(1);
663

664
        GROW_ARRAY(input_streams, nb_input_streams);
665 666 667 668 669 670
        input_streams[nb_input_streams - 1] = ist;

        ist->st = st;
        ist->file_index = nb_input_files;
        ist->discard = 1;
        st->discard  = AVDISCARD_ALL;
671 672 673
        ist->nb_samples = 0;
        ist->min_pts = INT64_MAX;
        ist->max_pts = INT64_MIN;
674 675 676 677

        ist->ts_scale = 1.0;
        MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);

678 679 680
        ist->autorotate = 1;
        MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);

681 682 683 684 685 686 687 688
        MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
        if (codec_tag) {
            uint32_t tag = strtol(codec_tag, &next, 0);
            if (*next)
                tag = AV_RL32(codec_tag);
            st->codec->codec_tag = tag;
        }

689
        ist->dec = choose_decoder(o, ic, st);
690
        ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
691

692 693 694
        ist->reinit_filters = -1;
        MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);

695 696 697 698 699 700 701 702
        MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
        ist->user_set_discard = AVDISCARD_NONE;
        if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
            av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
                    discard_str);
            exit_program(1);
        }

703 704
        ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;

705 706 707 708 709 710 711 712 713 714 715 716
        ist->dec_ctx = avcodec_alloc_context3(ist->dec);
        if (!ist->dec_ctx) {
            av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
            exit_program(1);
        }

        ret = avcodec_copy_context(ist->dec_ctx, dec);
        if (ret < 0) {
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
            exit_program(1);
        }

717 718
        switch (dec->codec_type) {
        case AVMEDIA_TYPE_VIDEO:
719 720
            if(!ist->dec)
                ist->dec = avcodec_find_decoder(dec->codec_id);
721
#if FF_API_EMU_EDGE
722
            if (av_codec_get_lowres(dec)) {
723 724
                dec->flags |= CODEC_FLAG_EMU_EDGE;
            }
725
#endif
726

727 728 729
            ist->resample_height  = ist->dec_ctx->height;
            ist->resample_width   = ist->dec_ctx->width;
            ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
730 731 732 733 734 735

            MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
            if (framerate && av_parse_video_rate(&ist->framerate,
                                                 framerate) < 0) {
                av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
                       framerate);
736
                exit_program(1);
737 738
            }

739 740 741
            ist->top_field_first = -1;
            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);

742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
            MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
            if (hwaccel) {
                if (!strcmp(hwaccel, "none"))
                    ist->hwaccel_id = HWACCEL_NONE;
                else if (!strcmp(hwaccel, "auto"))
                    ist->hwaccel_id = HWACCEL_AUTO;
                else {
                    int i;
                    for (i = 0; hwaccels[i].name; i++) {
                        if (!strcmp(hwaccels[i].name, hwaccel)) {
                            ist->hwaccel_id = hwaccels[i].id;
                            break;
                        }
                    }

                    if (!ist->hwaccel_id) {
                        av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
                               hwaccel);
                        av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
                        for (i = 0; hwaccels[i].name; i++)
                            av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
                        av_log(NULL, AV_LOG_FATAL, "\n");
                        exit_program(1);
                    }
                }
            }

            MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
            if (hwaccel_device) {
                ist->hwaccel_device = av_strdup(hwaccel_device);
                if (!ist->hwaccel_device)
                    exit_program(1);
            }
775 776 777 778 779 780 781 782 783 784 785 786 787

            MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
                                 hwaccel_output_format, ic, st);
            if (hwaccel_output_format) {
                ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
                if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
                    av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
                           "format: %s", hwaccel_output_format);
                }
            } else {
                ist->hwaccel_output_format = AV_PIX_FMT_NONE;
            }

788
            ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
789

790 791
            break;
        case AVMEDIA_TYPE_AUDIO:
792 793
            ist->guess_layout_max = INT_MAX;
            MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
794 795
            guess_input_channel_layout(ist);

796 797 798 799
            ist->resample_sample_fmt     = ist->dec_ctx->sample_fmt;
            ist->resample_sample_rate    = ist->dec_ctx->sample_rate;
            ist->resample_channels       = ist->dec_ctx->channels;
            ist->resample_channel_layout = ist->dec_ctx->channel_layout;
800 801 802

            break;
        case AVMEDIA_TYPE_DATA:
803 804
        case AVMEDIA_TYPE_SUBTITLE: {
            char *canvas_size = NULL;
805 806
            if(!ist->dec)
                ist->dec = avcodec_find_decoder(dec->codec_id);
807
            MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
808 809
            MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
            if (canvas_size &&
810
                av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
811
                av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
812
                exit_program(1);
813
            }
814
            break;
815
        }
816 817 818 819 820 821 822 823 824 825 826
        case AVMEDIA_TYPE_ATTACHMENT:
        case AVMEDIA_TYPE_UNKNOWN:
            break;
        default:
            abort();
        }
    }
}

static void assert_file_overwrite(const char *filename)
{
827
    if (file_overwrite && no_file_overwrite) {
828 829 830 831
        fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
        exit_program(1);
    }

832 833 834
    if (!file_overwrite) {
        const char *proto_name = avio_find_protocol_name(filename);
        if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
835
            if (stdin_interaction && !no_file_overwrite) {
836 837
                fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
                fflush(stderr);
838 839
                term_exit();
                signal(SIGINT, SIG_DFL);
840
                if (!read_yesno()) {
841
                    av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
842
                    exit_program(1);
843
                }
844
                term_init();
845 846
            }
            else {
847
                av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
848
                exit_program(1);
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869
            }
        }
    }
}

static void dump_attachment(AVStream *st, const char *filename)
{
    int ret;
    AVIOContext *out = NULL;
    AVDictionaryEntry *e;

    if (!st->codec->extradata_size) {
        av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
               nb_input_files - 1, st->index);
        return;
    }
    if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
        filename = e->value;
    if (!*filename) {
        av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
               "in stream #%d:%d.\n", nb_input_files - 1, st->index);
870
        exit_program(1);
871 872 873 874 875 876 877
    }

    assert_file_overwrite(filename);

    if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
        av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
               filename);
878
        exit_program(1);
879 880 881 882 883 884 885
    }

    avio_write(out, st->codec->extradata, st->codec->extradata_size);
    avio_flush(out);
    avio_close(out);
}

886
static int open_input_file(OptionsContext *o, const char *filename)
887
{
888
    InputFile *f;
889 890 891 892 893
    AVFormatContext *ic;
    AVInputFormat *file_iformat = NULL;
    int err, i, ret;
    int64_t timestamp;
    AVDictionary **opts;
894 895
    AVDictionary *unused_opts = NULL;
    AVDictionaryEntry *e = NULL;
896
    int orig_nb_streams;                     // number of streams before avformat_find_stream_info
897 898 899
    char *   video_codec_name = NULL;
    char *   audio_codec_name = NULL;
    char *subtitle_codec_name = NULL;
900
    char *    data_codec_name = NULL;
901
    int scan_all_pmts_set = 0;
902 903 904 905

    if (o->format) {
        if (!(file_iformat = av_find_input_format(o->format))) {
            av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
906
            exit_program(1);
907 908 909 910 911 912
        }
    }

    if (!strcmp(filename, "-"))
        filename = "pipe:";

913 914
    stdin_interaction &= strncmp(filename, "pipe:", 5) &&
                         strcmp(filename, "/dev/stdin");
915 916 917 918 919

    /* get default parameters from command line */
    ic = avformat_alloc_context();
    if (!ic) {
        print_error(filename, AVERROR(ENOMEM));
920
        exit_program(1);
921 922
    }
    if (o->nb_audio_sample_rate) {
923
        av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
924 925 926 927 928 929 930 931
    }
    if (o->nb_audio_channels) {
        /* because we set audio_channels based on both the "ac" and
         * "channel_layout" options, we need to check that the specified
         * demuxer actually has the "channels" option before setting it */
        if (file_iformat && file_iformat->priv_class &&
            av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
                        AV_OPT_SEARCH_FAKE_OBJ)) {
932
            av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
933 934 935 936 937 938 939 940
        }
    }
    if (o->nb_frame_rates) {
        /* set the format-level framerate option;
         * this is important for video grabbers, e.g. x11 */
        if (file_iformat && file_iformat->priv_class &&
            av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
                        AV_OPT_SEARCH_FAKE_OBJ)) {
941
            av_dict_set(&o->g->format_opts, "framerate",
942 943 944 945
                        o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
        }
    }
    if (o->nb_frame_sizes) {
946
        av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
947 948
    }
    if (o->nb_frame_pix_fmts)
949
        av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
950

951 952 953
    MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
    MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
    MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
954
    MATCH_PER_TYPE_OPT(codec_names, str,     data_codec_name, ic, "d");
955

956 957 958 959 960 961
    ic->video_codec_id   = video_codec_name ?
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : AV_CODEC_ID_NONE;
    ic->audio_codec_id   = audio_codec_name ?
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : AV_CODEC_ID_NONE;
    ic->subtitle_codec_id= subtitle_codec_name ?
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
962 963
    ic->data_codec_id    = data_codec_name ?
        find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
964 965 966 967 968 969 970

    if (video_codec_name)
        av_format_set_video_codec   (ic, find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0));
    if (audio_codec_name)
        av_format_set_audio_codec   (ic, find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0));
    if (subtitle_codec_name)
        av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
971 972
    if (data_codec_name)
        av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
973

974 975 976
    ic->flags |= AVFMT_FLAG_NONBLOCK;
    ic->interrupt_callback = int_cb;

977 978 979 980
    if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
        av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
        scan_all_pmts_set = 1;
    }
981
    /* open the input file with generic avformat function */
982
    err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
983 984
    if (err < 0) {
        print_error(filename, err);
985
        exit_program(1);
986
    }
987 988
    if (scan_all_pmts_set)
        av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
989
    remove_avoptions(&o->g->format_opts, o->g->codec_opts);
990
    assert_avoptions(o->g->format_opts);
991 992 993 994 995 996

    /* apply forced codec ids */
    for (i = 0; i < ic->nb_streams; i++)
        choose_decoder(o, ic, ic->streams[i]);

    /* Set AVCodecContext options for avformat_find_stream_info */
997
    opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
998 999 1000 1001 1002 1003 1004
    orig_nb_streams = ic->nb_streams;

    /* If not enough info to get the stream parameters, we decode the
       first frames to get it. (used in mpeg case for example) */
    ret = avformat_find_stream_info(ic, opts);
    if (ret < 0) {
        av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1005 1006 1007 1008
        if (ic->nb_streams == 0) {
            avformat_close_input(&ic);
            exit_program(1);
        }
1009 1010
    }

1011 1012 1013 1014 1015 1016
    if (o->start_time_eof != AV_NOPTS_VALUE) {
        if (ic->duration>0) {
            o->start_time = o->start_time_eof + ic->duration;
        } else
            av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
    }
1017
    timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1018
    /* add the stream start time */
1019
    if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1020 1021 1022
        timestamp += ic->start_time;

    /* if seeking requested, we execute it */
1023
    if (o->start_time != AV_NOPTS_VALUE) {
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
        int64_t seek_timestamp = timestamp;

        if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
            int dts_heuristic = 0;
            for (i=0; i<ic->nb_streams; i++) {
                AVCodecContext *avctx = ic->streams[i]->codec;
                if (avctx->has_b_frames)
                    dts_heuristic = 1;
            }
            if (dts_heuristic) {
                seek_timestamp -= 3*AV_TIME_BASE / 23;
            }
        }
        ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
        if (ret < 0) {
            av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
                   filename, (double)timestamp / AV_TIME_BASE);
        }
    }

    /* update the current parameters so that they match the one of the input stream */
    add_input_streams(o, ic);

    /* dump the file content */
    av_dump_format(ic, nb_input_files, filename, 0);

1050
    GROW_ARRAY(input_files, nb_input_files);
1051 1052
    f = av_mallocz(sizeof(*f));
    if (!f)
1053
        exit_program(1);
1054
    input_files[nb_input_files - 1] = f;
1055

1056 1057
    f->ctx        = ic;
    f->ist_index  = nb_input_streams - ic->nb_streams;
1058
    f->start_time = o->start_time;
1059
    f->recording_time = o->recording_time;
1060
    f->input_ts_offset = o->input_ts_offset;
1061
    f->ts_offset  = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1062 1063
    f->nb_streams = ic->nb_streams;
    f->rate_emu   = o->rate_emu;
1064
    f->accurate_seek = o->accurate_seek;
1065 1066 1067
    f->loop = o->loop;
    f->duration = 0;
    f->time_base = (AVRational){ 1, 1 };
1068 1069 1070
#if HAVE_PTHREADS
    f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
#endif
1071

1072 1073 1074 1075
    /* check if all codec options have been used */
    unused_opts = strip_specifiers(o->g->codec_opts);
    for (i = f->ist_index; i < nb_input_streams; i++) {
        e = NULL;
1076
        while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1077 1078 1079 1080 1081 1082 1083 1084 1085
                                AV_DICT_IGNORE_SUFFIX)))
            av_dict_set(&unused_opts, e->key, NULL, 0);
    }

    e = NULL;
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
        const AVClass *class = avcodec_get_class();
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1086 1087 1088 1089
        const AVClass *fclass = avformat_get_class();
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
        if (!option || foption)
1090
            continue;
1091 1092


1093 1094 1095 1096 1097
        if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
                   "input file #%d (%s) is not a decoding option.\n", e->key,
                   option->help ? option->help : "", nb_input_files - 1,
                   filename);
1098
            exit_program(1);
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
        }

        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
               "input file #%d (%s) has not been used for any stream. The most "
               "likely reason is either wrong type (e.g. a video option with "
               "no video streams) or that it is a private option of some decoder "
               "which was not actually used for any stream.\n", e->key,
               option->help ? option->help : "", nb_input_files - 1, filename);
    }
    av_dict_free(&unused_opts);

1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124
    for (i = 0; i < o->nb_dump_attachment; i++) {
        int j;

        for (j = 0; j < ic->nb_streams; j++) {
            AVStream *st = ic->streams[j];

            if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
                dump_attachment(st, o->dump_attachment[i].u.str);
        }
    }

    for (i = 0; i < orig_nb_streams; i++)
        av_dict_free(&opts[i]);
    av_freep(&opts);

1125 1126
    input_stream_potentially_available = 1;

1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
    return 0;
}

static uint8_t *get_line(AVIOContext *s)
{
    AVIOContext *line;
    uint8_t *buf;
    char c;

    if (avio_open_dyn_buf(&line) < 0) {
        av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1138
        exit_program(1);
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
    }

    while ((c = avio_r8(s)) && c != '\n')
        avio_w8(line, c);
    avio_w8(line, 0);
    avio_close_dyn_buf(line, &buf);

    return buf;
}

static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
{
1151
    int i, ret = -1;
1152 1153 1154 1155 1156 1157
    char filename[1000];
    const char *base[3] = { getenv("AVCONV_DATADIR"),
                            getenv("HOME"),
                            AVCONV_DATADIR,
                            };

1158
    for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1159 1160 1161 1162 1163 1164 1165
        if (!base[i])
            continue;
        if (codec_name) {
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
                     i != 1 ? "" : "/.avconv", codec_name, preset_name);
            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
        }
1166
        if (ret < 0) {
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
            snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
                     i != 1 ? "" : "/.avconv", preset_name);
            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
        }
    }
    return ret;
}

static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
{
    char *codec_name = NULL;

    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
    if (!codec_name) {
        ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
                                                  NULL, ost->st->codec->codec_type);
        ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
    } else if (!strcmp(codec_name, "copy"))
        ost->stream_copy = 1;
    else {
        ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
        ost->st->codec->codec_id = ost->enc->id;
    }
}

1192
static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1193 1194 1195 1196 1197 1198 1199
{
    OutputStream *ost;
    AVStream *st = avformat_new_stream(oc, NULL);
    int idx      = oc->nb_streams - 1, ret = 0;
    char *bsf = NULL, *next, *codec_tag = NULL;
    AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
    double qscale = -1;
1200
    int i;
1201 1202 1203

    if (!st) {
        av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1204
        exit_program(1);
1205 1206 1207 1208 1209
    }

    if (oc->nb_streams - 1 < o->nb_streamid_map)
        st->id = o->streamid_map[oc->nb_streams - 1];

1210
    GROW_ARRAY(output_streams, nb_output_streams);
1211
    if (!(ost = av_mallocz(sizeof(*ost))))
1212
        exit_program(1);
1213 1214
    output_streams[nb_output_streams - 1] = ost;

1215
    ost->file_index = nb_output_files - 1;
1216 1217 1218 1219
    ost->index      = idx;
    ost->st         = st;
    st->codec->codec_type = type;
    choose_encoder(o, oc, ost);
1220 1221 1222 1223 1224 1225 1226 1227

    ost->enc_ctx = avcodec_alloc_context3(ost->enc);
    if (!ost->enc_ctx) {
        av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
        exit_program(1);
    }
    ost->enc_ctx->codec_type = type;

1228
    if (ost->enc) {
1229 1230 1231
        AVIOContext *s = NULL;
        char *buf = NULL, *arg = NULL, *preset = NULL;

1232
        ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243

        MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
        if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
            do  {
                buf = get_line(s);
                if (!buf[0] || buf[0] == '#') {
                    av_free(buf);
                    continue;
                }
                if (!(arg = strchr(buf, '='))) {
                    av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1244
                    exit_program(1);
1245 1246
                }
                *arg++ = 0;
1247
                av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1248 1249
                av_free(buf);
            } while (!s->eof_reached);
1250
            avio_closep(&s);
1251 1252 1253 1254 1255
        }
        if (ret) {
            av_log(NULL, AV_LOG_FATAL,
                   "Preset %s specified for stream %d:%d, but could not be opened.\n",
                   preset, ost->file_index, ost->index);
1256
            exit_program(1);
1257
        }
1258
    } else {
1259
        ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1260 1261 1262 1263
    }

    ost->max_frames = INT64_MAX;
    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1264 1265 1266 1267 1268 1269 1270
    for (i = 0; i<o->nb_max_frames; i++) {
        char *p = o->max_frames[i].specifier;
        if (!*p && type != AVMEDIA_TYPE_VIDEO) {
            av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
            break;
        }
    }
1271

1272 1273 1274
    ost->copy_prior_start = -1;
    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);

1275 1276
    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
    while (bsf) {
1277
        char *arg = NULL;
1278 1279
        if (next = strchr(bsf, ','))
            *next++ = 0;
1280 1281
        if (arg = strchr(bsf, '='))
            *arg++ = 0;
1282 1283
        if (!(bsfc = av_bitstream_filter_init(bsf))) {
            av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1284
            exit_program(1);
1285 1286 1287 1288 1289
        }
        if (bsfc_prev)
            bsfc_prev->next = bsfc;
        else
            ost->bitstream_filters = bsfc;
1290 1291 1292 1293 1294
        if (arg)
            if (!(bsfc->args = av_strdup(arg))) {
                av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
                exit_program(1);
            }
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304

        bsfc_prev = bsfc;
        bsf       = next;
    }

    MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
    if (codec_tag) {
        uint32_t tag = strtol(codec_tag, &next, 0);
        if (*next)
            tag = AV_RL32(codec_tag);
1305
        ost->st->codec->codec_tag =
1306
        ost->enc_ctx->codec_tag = tag;
1307 1308 1309
    }

    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1310
    if (qscale >= 0) {
1311
        ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1312
        ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1313 1314
    }

1315 1316 1317
    MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
    ost->disposition = av_strdup(ost->disposition);

1318
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1319
        ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1320

1321
    av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1322 1323

    av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1324
    if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1325
        av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1326

1327 1328
    av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);

1329 1330 1331 1332
    ost->source_index = source_index;
    if (source_index >= 0) {
        ost->sync_ist = input_streams[source_index];
        input_streams[source_index]->discard = 0;
1333
        input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1334
    }
1335
    ost->last_mux_dts = AV_NOPTS_VALUE;
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350

    return ost;
}

static void parse_matrix_coeffs(uint16_t *dest, const char *str)
{
    int i;
    const char *p = str;
    for (i = 0;; i++) {
        dest[i] = atoi(p);
        if (i == 63)
            break;
        p = strchr(p, ',');
        if (!p) {
            av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1351
            exit_program(1);
1352 1353 1354 1355 1356
        }
        p++;
    }
}

1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
/* read file contents into a string */
static uint8_t *read_file(const char *filename)
{
    AVIOContext *pb      = NULL;
    AVIOContext *dyn_buf = NULL;
    int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
    uint8_t buf[1024], *str;

    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
        return NULL;
    }

    ret = avio_open_dyn_buf(&dyn_buf);
    if (ret < 0) {
        avio_closep(&pb);
        return NULL;
    }
    while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
        avio_write(dyn_buf, buf, ret);
    avio_w8(dyn_buf, 0);
    avio_closep(&pb);

    ret = avio_close_dyn_buf(dyn_buf, &str);
    if (ret < 0)
        return NULL;
    return str;
}

static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
                             OutputStream *ost)
{
    AVStream *st = ost->st;

1391
    if (ost->filters_script && ost->filters) {
1392 1393
        av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
               "output stream #%d:%d.\n", nb_output_files, st->index);
1394
        exit_program(1);
1395 1396
    }

1397 1398 1399 1400
    if (ost->filters_script)
        return read_file(ost->filters_script);
    else if (ost->filters)
        return av_strdup(ost->filters);
1401 1402 1403 1404 1405

    return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
                     "null" : "anull");
}

1406 1407 1408
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
                                     const OutputStream *ost, enum AVMediaType type)
{
1409
    if (ost->filters_script || ost->filters) {
1410
        av_log(NULL, AV_LOG_ERROR,
1411
               "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1412
               "Filtering and streamcopy cannot be used together.\n",
1413 1414 1415
               ost->filters ? "Filtergraph" : "Filtergraph script",
               ost->filters ? ost->filters : ost->filters_script,
               av_get_media_type_string(type), ost->file_index, ost->index);
1416 1417 1418 1419
        exit_program(1);
    }
}

1420
static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1421 1422 1423 1424
{
    AVStream *st;
    OutputStream *ost;
    AVCodecContext *video_enc;
1425
    char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1426

1427
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1428
    st  = ost->st;
1429
    video_enc = ost->enc_ctx;
1430

1431 1432 1433
    MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
    if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
        av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1434
        exit_program(1);
1435
    }
1436 1437
    if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
        av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1438

1439 1440 1441 1442 1443 1444
    MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
    if (frame_aspect_ratio) {
        AVRational q;
        if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
            q.num <= 0 || q.den <= 0) {
            av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1445
            exit_program(1);
1446 1447 1448 1449
        }
        ost->frame_aspect_ratio = q;
    }

1450 1451 1452
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);

1453 1454
    if (!ost->stream_copy) {
        const char *p = NULL;
1455
        char *frame_size = NULL;
1456
        char *frame_pix_fmt = NULL;
1457
        char *intra_matrix = NULL, *inter_matrix = NULL;
1458
        char *chroma_intra_matrix = NULL;
1459
        int do_pass = 0;
1460 1461 1462 1463 1464
        int i;

        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
        if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1465
            exit_program(1);
1466 1467
        }

1468
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1469
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1470 1471 1472 1473 1474
        if (frame_pix_fmt && *frame_pix_fmt == '+') {
            ost->keep_pix_fmt = 1;
            if (!*++frame_pix_fmt)
                frame_pix_fmt = NULL;
        }
1475
        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1476
            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1477
            exit_program(1);
1478 1479 1480
        }
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;

1481 1482
        if (intra_only)
            video_enc->gop_size = 0;
1483 1484 1485 1486
        MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
        if (intra_matrix) {
            if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1487
                exit_program(1);
1488 1489 1490
            }
            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
        }
1491 1492 1493 1494 1495 1496 1497 1498 1499 1500
        MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
        if (chroma_intra_matrix) {
            uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
            if (!p) {
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
                exit_program(1);
            }
            av_codec_set_chroma_intra_matrix(video_enc, p);
            parse_matrix_coeffs(p, chroma_intra_matrix);
        }
1501 1502 1503 1504
        MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
        if (inter_matrix) {
            if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1505
                exit_program(1);
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
            }
            parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
        }

        MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
        for (i = 0; p; i++) {
            int start, end, q;
            int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
            if (e != 3) {
                av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1516
                exit_program(1);
1517 1518
            }
            video_enc->rc_override =
1519 1520
                av_realloc_array(video_enc->rc_override,
                                 i + 1, sizeof(RcOverride));
1521 1522
            if (!video_enc->rc_override) {
                av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1523
                exit_program(1);
1524
            }
1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
            video_enc->rc_override[i].start_frame = start;
            video_enc->rc_override[i].end_frame   = end;
            if (q > 0) {
                video_enc->rc_override[i].qscale         = q;
                video_enc->rc_override[i].quality_factor = 1.0;
            }
            else {
                video_enc->rc_override[i].qscale         = 0;
                video_enc->rc_override[i].quality_factor = -q/100.0;
            }
            p = strchr(p, '/');
            if (p) p++;
        }
        video_enc->rc_override_count = i;

1540
        if (do_psnr)
1541
            video_enc->flags|= AV_CODEC_FLAG_PSNR;
1542

1543
        /* two pass mode */
1544
        MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1545
        if (do_pass) {
1546
            if (do_pass & 1) {
1547
                video_enc->flags |= AV_CODEC_FLAG_PASS1;
1548
                av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1549 1550
            }
            if (do_pass & 2) {
1551
                video_enc->flags |= AV_CODEC_FLAG_PASS2;
1552
                av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1553 1554 1555
            }
        }

1556 1557 1558
        MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
        if (ost->logfile_prefix &&
            !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1559
            exit_program(1);
1560

1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571
        if (do_pass) {
            char logfilename[1024];
            FILE *f;

            snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
                     ost->logfile_prefix ? ost->logfile_prefix :
                                           DEFAULT_PASS_LOGFILENAME_PREFIX,
                     i);
            if (!strcmp(ost->enc->name, "libx264")) {
                av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
            } else {
1572
                if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1573 1574 1575
                    char  *logbuffer = read_file(logfilename);

                    if (!logbuffer) {
1576 1577 1578 1579 1580 1581
                        av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
                               logfilename);
                        exit_program(1);
                    }
                    video_enc->stats_in = logbuffer;
                }
1582
                if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1583 1584 1585 1586 1587 1588 1589 1590 1591
                    f = av_fopen_utf8(logfilename, "wb");
                    if (!f) {
                        av_log(NULL, AV_LOG_FATAL,
                               "Cannot write log file '%s' for pass-1 encoding: %s\n",
                               logfilename, strerror(errno));
                        exit_program(1);
                    }
                    ost->logfile = f;
                }
1592 1593 1594
            }
        }

1595 1596 1597 1598 1599 1600 1601 1602 1603
        MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
        if (ost->forced_keyframes)
            ost->forced_keyframes = av_strdup(ost->forced_keyframes);

        MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);

        ost->top_field_first = -1;
        MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);

1604 1605 1606

        ost->avfilter = get_ost_filters(o, oc, ost);
        if (!ost->avfilter)
1607
            exit_program(1);
1608 1609 1610 1611
    } else {
        MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
    }

1612 1613 1614
    if (ost->stream_copy)
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);

1615 1616 1617
    return ost;
}

1618
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1619
{
1620
    int n;
1621 1622 1623 1624
    AVStream *st;
    OutputStream *ost;
    AVCodecContext *audio_enc;

1625
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1626 1627
    st  = ost->st;

1628
    audio_enc = ost->enc_ctx;
1629 1630
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;

1631 1632 1633
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);

1634 1635 1636 1637 1638 1639 1640 1641 1642
    if (!ost->stream_copy) {
        char *sample_fmt = NULL;

        MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);

        MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
        if (sample_fmt &&
            (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
            av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1643
            exit_program(1);
1644 1645 1646 1647
        }

        MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);

1648 1649 1650
        MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
        ost->apad = av_strdup(ost->apad);

1651 1652
        ost->avfilter = get_ost_filters(o, oc, ost);
        if (!ost->avfilter)
1653
            exit_program(1);
1654 1655 1656 1657

        /* check for channel mapping for this audio stream */
        for (n = 0; n < o->nb_audio_channel_maps; n++) {
            AudioChannelMap *map = &o->audio_channel_maps[n];
1658
            if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1659
                (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1660 1661 1662 1663 1664 1665
                InputStream *ist;

                if (map->channel_idx == -1) {
                    ist = NULL;
                } else if (ost->source_index < 0) {
                    av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1666
                           ost->file_index, ost->st->index);
1667 1668 1669 1670 1671 1672
                    continue;
                } else {
                    ist = input_streams[ost->source_index];
                }

                if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1673 1674 1675 1676 1677 1678 1679
                    if (av_reallocp_array(&ost->audio_channels_map,
                                          ost->audio_channels_mapped + 1,
                                          sizeof(*ost->audio_channels_map)
                                          ) < 0 )
                        exit_program(1);

                    ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1680
                }
1681 1682
            }
        }
1683 1684
    }

1685 1686 1687
    if (ost->stream_copy)
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);

1688 1689 1690
    return ost;
}

1691
static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1692 1693 1694
{
    OutputStream *ost;

1695
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1696 1697
    if (!ost->stream_copy) {
        av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1698
        exit_program(1);
1699 1700 1701 1702 1703
    }

    return ost;
}

1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
{
    OutputStream *ost;

    ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
    if (!ost->stream_copy) {
        av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
        exit_program(1);
    }

    return ost;
}

1717
static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1718
{
1719
    OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1720
    ost->stream_copy = 1;
1721
    ost->finished    = 1;
1722 1723 1724
    return ost;
}

1725
static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1726 1727 1728 1729 1730
{
    AVStream *st;
    OutputStream *ost;
    AVCodecContext *subtitle_enc;

1731
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1732
    st  = ost->st;
1733
    subtitle_enc = ost->enc_ctx;
1734 1735 1736

    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;

1737 1738
    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);

1739 1740 1741 1742 1743 1744
    if (!ost->stream_copy) {
        char *frame_size = NULL;

        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
        if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1745
            exit_program(1);
1746 1747 1748
        }
    }

1749 1750 1751 1752
    return ost;
}

/* arg format is "output-stream-index:streamid-value". */
1753
static int opt_streamid(void *optctx, const char *opt, const char *arg)
1754
{
1755
    OptionsContext *o = optctx;
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765
    int idx;
    char *p;
    char idx_str[16];

    av_strlcpy(idx_str, arg, sizeof(idx_str));
    p = strchr(idx_str, ':');
    if (!p) {
        av_log(NULL, AV_LOG_FATAL,
               "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
               arg, opt);
1766
        exit_program(1);
1767 1768
    }
    *p++ = '\0';
1769
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1770 1771 1772 1773 1774 1775 1776 1777 1778
    o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
    o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
    return 0;
}

static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
{
    AVFormatContext *is = ifile->ctx;
    AVFormatContext *os = ofile->ctx;
1779
    AVChapter **tmp;
1780 1781
    int i;

1782
    tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1783 1784 1785 1786
    if (!tmp)
        return AVERROR(ENOMEM);
    os->chapters = tmp;

1787 1788
    for (i = 0; i < is->nb_chapters; i++) {
        AVChapter *in_ch = is->chapters[i], *out_ch;
1789 1790
        int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
        int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812
                                       AV_TIME_BASE_Q, in_ch->time_base);
        int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
                           av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);


        if (in_ch->end < ts_off)
            continue;
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
            break;

        out_ch = av_mallocz(sizeof(AVChapter));
        if (!out_ch)
            return AVERROR(ENOMEM);

        out_ch->id        = in_ch->id;
        out_ch->time_base = in_ch->time_base;
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);

        if (copy_metadata)
            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);

1813
        os->chapters[os->nb_chapters++] = out_ch;
1814 1815 1816 1817
    }
    return 0;
}

1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831
static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
{
    int i, err;
    AVFormatContext *ic = avformat_alloc_context();

    ic->interrupt_callback = int_cb;
    err = avformat_open_input(&ic, filename, NULL, NULL);
    if (err < 0)
        return err;
    /* copy stream format */
    for(i=0;i<ic->nb_streams;i++) {
        AVStream *st;
        OutputStream *ost;
        AVCodec *codec;
1832
        const char *enc_config;
1833 1834

        codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1835 1836 1837 1838
        if (!codec) {
            av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
            return AVERROR(EINVAL);
        }
1839 1840 1841 1842
        if (codec->type == AVMEDIA_TYPE_AUDIO)
            opt_audio_codec(o, "c:a", codec->name);
        else if (codec->type == AVMEDIA_TYPE_VIDEO)
            opt_video_codec(o, "c:v", codec->name);
1843 1844 1845
        ost   = new_output_stream(o, s, codec->type, -1);
        st    = ost->st;

1846 1847 1848 1849 1850 1851 1852 1853
        avcodec_get_context_defaults3(st->codec, codec);
        enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
        if (enc_config) {
            AVDictionary *opts = NULL;
            av_dict_parse_string(&opts, enc_config, "=", ",", 0);
            av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
            av_dict_free(&opts);
        }
1854 1855 1856 1857

        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
            choose_sample_fmt(st, codec);
        else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1858
            choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1859 1860 1861
        avcodec_copy_context(ost->enc_ctx, st->codec);
        if (enc_config)
            av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1862 1863 1864
    }

    avformat_close_input(&ic);
1865
    return err;
1866 1867
}

1868 1869 1870 1871 1872
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
                               AVFormatContext *oc)
{
    OutputStream *ost;

1873
    switch (ofilter->type) {
1874 1875
    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1876 1877 1878
    default:
        av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
               "currently.\n");
1879
        exit_program(1);
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890
    }

    ost->source_index = -1;
    ost->filter       = ofilter;

    ofilter->ost      = ost;

    if (ost->stream_copy) {
        av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
               "which is fed from a complex filtergraph. Filtering and streamcopy "
               "cannot be used together.\n", ost->file_index, ost->index);
1891
        exit_program(1);
1892 1893
    }

1894
    if (ost->avfilter && (ost->filters || ost->filters_script)) {
1895 1896 1897 1898 1899 1900 1901 1902 1903
        const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
        av_log(NULL, AV_LOG_ERROR,
               "%s '%s' was specified through the %s option "
               "for output stream %d:%d, which is fed from a complex filtergraph.\n"
               "%s and -filter_complex cannot be used together for the same stream.\n",
               ost->filters ? "Filtergraph" : "Filtergraph script",
               ost->filters ? ost->filters : ost->filters_script,
               opt, ost->file_index, ost->index, opt);
        exit_program(1);
1904 1905
    }

1906 1907 1908
    avfilter_inout_free(&ofilter->out_tmp);
}

1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920
static int init_complex_filters(void)
{
    int i, ret = 0;

    for (i = 0; i < nb_filtergraphs; i++) {
        ret = init_complex_filtergraph(filtergraphs[i]);
        if (ret < 0)
            return ret;
    }
    return 0;
}

1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931
static int configure_complex_filters(void)
{
    int i, ret = 0;

    for (i = 0; i < nb_filtergraphs; i++)
        if (!filtergraphs[i]->graph &&
            (ret = configure_filtergraph(filtergraphs[i])) < 0)
            return ret;
    return 0;
}

1932
static int open_output_file(OptionsContext *o, const char *filename)
1933 1934 1935 1936
{
    AVFormatContext *oc;
    int i, j, err;
    AVOutputFormat *file_oformat;
1937
    OutputFile *of;
1938 1939
    OutputStream *ost;
    InputStream  *ist;
1940 1941
    AVDictionary *unused_opts = NULL;
    AVDictionaryEntry *e = NULL;
1942 1943


1944 1945 1946 1947 1948 1949
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
        o->stop_time = INT64_MAX;
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
    }

    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1950 1951
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
        if (o->stop_time <= start_time) {
1952 1953
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
            exit_program(1);
1954
        } else {
1955
            o->recording_time = o->stop_time - start_time;
1956 1957 1958
        }
    }

1959 1960 1961
    GROW_ARRAY(output_files, nb_output_files);
    of = av_mallocz(sizeof(*of));
    if (!of)
1962
        exit_program(1);
1963 1964 1965 1966 1967 1968 1969 1970 1971
    output_files[nb_output_files - 1] = of;

    of->ost_index      = nb_output_streams;
    of->recording_time = o->recording_time;
    of->start_time     = o->start_time;
    of->limit_filesize = o->limit_filesize;
    of->shortest       = o->shortest;
    av_dict_copy(&of->opts, o->g->format_opts, 0);

1972 1973 1974
    if (!strcmp(filename, "-"))
        filename = "pipe:";

1975
    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1976
    if (!oc) {
1977
        print_error(filename, err);
1978
        exit_program(1);
1979
    }
1980

1981 1982 1983
    of->ctx = oc;
    if (o->recording_time != INT64_MAX)
        oc->duration = o->recording_time;
1984

1985
    file_oformat= oc->oformat;
1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996
    oc->interrupt_callback = int_cb;

    /* create streams for all unlabeled output pads */
    for (i = 0; i < nb_filtergraphs; i++) {
        FilterGraph *fg = filtergraphs[i];
        for (j = 0; j < fg->nb_outputs; j++) {
            OutputFilter *ofilter = fg->outputs[j];

            if (!ofilter->out_tmp || ofilter->out_tmp->name)
                continue;

1997
            switch (ofilter->type) {
1998 1999 2000 2001 2002 2003 2004 2005
            case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
            case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
            case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
            }
            init_output_filter(ofilter, o, oc);
        }
    }

2006 2007 2008 2009 2010 2011 2012 2013 2014 2015
    /* ffserver seeking with date=... needs a date reference */
    if (!strcmp(file_oformat->name, "ffm") &&
        av_strstart(filename, "http:", NULL)) {
        int err = parse_option(o, "metadata", "creation_time=now", options);
        if (err < 0) {
            print_error(filename, err);
            exit_program(1);
        }
    }

2016
    if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2017 2018 2019 2020 2021 2022 2023
        av_strstart(filename, "http:", NULL)) {
        int j;
        /* special case for files sent to ffserver: we get the stream
           parameters from ffserver */
        int err = read_ffserver_streams(o, oc, filename);
        if (err < 0) {
            print_error(filename, err);
2024
            exit_program(1);
2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035
        }
        for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
            ost = output_streams[j];
            for (i = 0; i < nb_input_streams; i++) {
                ist = input_streams[i];
                if(ist->st->codec->codec_type == ost->st->codec->codec_type){
                    ost->sync_ist= ist;
                    ost->source_index= i;
                    if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
                    if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
                    ist->discard = 0;
2036
                    ist->st->discard = ist->user_set_discard;
2037 2038 2039 2040 2041
                    break;
                }
            }
            if(!ost->sync_ist){
                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));
2042
                exit_program(1);
2043
            }
2044
        }
2045
    } else if (!o->nb_stream_maps) {
2046
        char *subtitle_codec_name = NULL;
2047
        /* pick the "best" stream of each type */
2048 2049

        /* video: highest resolution */
2050
        if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2051
            int area = 0, idx = -1;
2052
            int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2053
            for (i = 0; i < nb_input_streams; i++) {
2054
                int new_area;
2055
                ist = input_streams[i];
2056
                new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
2057 2058
                if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
                    new_area = 1;
2059
                if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2060
                    new_area > area) {
2061 2062
                    if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
                        continue;
2063
                    area = new_area;
2064 2065 2066
                    idx = i;
                }
            }
2067 2068
            if (idx >= 0)
                new_video_stream(o, oc, idx);
2069 2070 2071
        }

        /* audio: most channels */
2072
        if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2073
            int best_score = 0, idx = -1;
2074
            for (i = 0; i < nb_input_streams; i++) {
2075
                int score;
2076
                ist = input_streams[i];
2077
                score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2078
                if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2079 2080
                    score > best_score) {
                    best_score = score;
2081 2082 2083
                    idx = i;
                }
            }
2084 2085
            if (idx >= 0)
                new_audio_stream(o, oc, idx);
2086 2087 2088
        }

        /* subtitles: pick first */
2089
        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2090
        if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2091 2092
            for (i = 0; i < nb_input_streams; i++)
                if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113
                    AVCodecDescriptor const *input_descriptor =
                        avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
                    AVCodecDescriptor const *output_descriptor = NULL;
                    AVCodec const *output_codec =
                        avcodec_find_encoder(oc->oformat->subtitle_codec);
                    int input_props = 0, output_props = 0;
                    if (output_codec)
                        output_descriptor = avcodec_descriptor_get(output_codec->id);
                    if (input_descriptor)
                        input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
                    if (output_descriptor)
                        output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
                    if (subtitle_codec_name ||
                        input_props & output_props ||
                        // Map dvb teletext which has neither property to any output subtitle encoder
                        input_descriptor && output_descriptor &&
                        (!input_descriptor->props ||
                         !output_descriptor->props)) {
                        new_subtitle_stream(o, oc, i);
                        break;
                    }
2114 2115
                }
        }
2116 2117 2118 2119 2120 2121 2122 2123 2124
        /* Data only if codec id match */
        if (!o->data_disable ) {
            enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
            for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
                if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
                    && input_streams[i]->st->codec->codec_id == codec_id )
                    new_data_stream(o, oc, i);
            }
        }
2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149
    } else {
        for (i = 0; i < o->nb_stream_maps; i++) {
            StreamMap *map = &o->stream_maps[i];

            if (map->disabled)
                continue;

            if (map->linklabel) {
                FilterGraph *fg;
                OutputFilter *ofilter = NULL;
                int j, k;

                for (j = 0; j < nb_filtergraphs; j++) {
                    fg = filtergraphs[j];
                    for (k = 0; k < fg->nb_outputs; k++) {
                        AVFilterInOut *out = fg->outputs[k]->out_tmp;
                        if (out && !strcmp(out->name, map->linklabel)) {
                            ofilter = fg->outputs[k];
                            goto loop_end;
                        }
                    }
                }
loop_end:
                if (!ofilter) {
                    av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2150
                           "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2151
                    exit_program(1);
2152 2153 2154
                }
                init_output_filter(ofilter, o, oc);
            } else {
2155 2156
                int src_idx = input_files[map->file_index]->ist_index + map->stream_index;

2157
                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2158 2159 2160 2161 2162 2163 2164 2165 2166
                if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
                    continue;
                if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
                    continue;
                if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
                    continue;
                if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
                    continue;

2167
                ost = NULL;
2168
                switch (ist->st->codec->codec_type) {
2169 2170 2171 2172 2173
                case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
                case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
                case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
                case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
                case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2174 2175 2176 2177 2178
                case AVMEDIA_TYPE_UNKNOWN:
                    if (copy_unknown_streams) {
                        ost = new_unknown_stream   (o, oc, src_idx);
                        break;
                    }
2179
                default:
2180
                    av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2181
                           "Cannot map stream #%d:%d - unsupported type.\n",
2182
                           map->file_index, map->stream_index);
2183 2184
                    if (!ignore_unknown_streams) {
                        av_log(NULL, AV_LOG_FATAL,
2185
                               "If you want unsupported types ignored instead "
2186 2187
                               "of failing, please use the -ignore_unknown option\n"
                               "If you want them copied, please use -copy_unknown\n");
2188
                        exit_program(1);
2189
                    }
2190
                }
2191 2192 2193
                if (ost)
                    ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
                                                  + map->sync_stream_index];
2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207
            }
        }
    }

    /* handle attached files */
    for (i = 0; i < o->nb_attachments; i++) {
        AVIOContext *pb;
        uint8_t *attachment;
        const char *p;
        int64_t len;

        if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
            av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
                   o->attachments[i]);
2208
            exit_program(1);
2209 2210 2211 2212
        }
        if ((len = avio_size(pb)) <= 0) {
            av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
                   o->attachments[i]);
2213
            exit_program(1);
2214 2215 2216 2217
        }
        if (!(attachment = av_malloc(len))) {
            av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
                   o->attachments[i]);
2218
            exit_program(1);
2219 2220 2221
        }
        avio_read(pb, attachment, len);

2222
        ost = new_attachment_stream(o, oc, -1);
2223
        ost->stream_copy               = 1;
2224
        ost->attachment_filename       = o->attachments[i];
2225
        ost->finished                  = 1;
2226 2227 2228 2229 2230
        ost->st->codec->extradata      = attachment;
        ost->st->codec->extradata_size = len;

        p = strrchr(o->attachments[i], '/');
        av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2231
        avio_closep(&pb);
2232 2233
    }

2234 2235 2236 2237
    for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
        AVDictionaryEntry *e;
        ost = output_streams[i];

2238
        if ((ost->stream_copy || ost->attachment_filename)
2239 2240 2241
            && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
            && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
            if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2242
                exit_program(1);
2243 2244
    }

2245 2246 2247 2248 2249 2250
    if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
        av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
        av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
        exit_program(1);
    }

2251 2252 2253 2254
    /* check if all codec options have been used */
    unused_opts = strip_specifiers(o->g->codec_opts);
    for (i = of->ost_index; i < nb_output_streams; i++) {
        e = NULL;
2255
        while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2256 2257 2258 2259 2260 2261 2262 2263 2264
                                AV_DICT_IGNORE_SUFFIX)))
            av_dict_set(&unused_opts, e->key, NULL, 0);
    }

    e = NULL;
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
        const AVClass *class = avcodec_get_class();
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2265 2266 2267 2268
        const AVClass *fclass = avformat_get_class();
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
        if (!option || foption)
2269
            continue;
2270 2271


2272 2273 2274 2275 2276
        if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
                   "output file #%d (%s) is not an encoding option.\n", e->key,
                   option->help ? option->help : "", nb_output_files - 1,
                   filename);
2277
            exit_program(1);
2278 2279
        }

2280 2281 2282 2283
        // gop_timecode is injected by generic code but not always used
        if (!strcmp(e->key, "gop_timecode"))
            continue;

2284 2285 2286 2287 2288 2289 2290 2291 2292
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
               "output file #%d (%s) has not been used for any stream. The most "
               "likely reason is either wrong type (e.g. a video option with "
               "no video streams) or that it is a private option of some encoder "
               "which was not actually used for any stream.\n", e->key,
               option->help ? option->help : "", nb_output_files - 1, filename);
    }
    av_dict_free(&unused_opts);

2293 2294 2295 2296 2297 2298 2299
    /* set the encoding/decoding_needed flags */
    for (i = of->ost_index; i < nb_output_streams; i++) {
        OutputStream *ost = output_streams[i];

        ost->encoding_needed = !ost->stream_copy;
        if (ost->encoding_needed && ost->source_index >= 0) {
            InputStream *ist = input_streams[ost->source_index];
2300
            ist->decoding_needed |= DECODING_FOR_OST;
2301 2302 2303
        }
    }

2304 2305 2306 2307
    /* check filename in case of an image number is expected */
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
        if (!av_filename_number_test(oc->filename)) {
            print_error(oc->filename, AVERROR(EINVAL));
2308
            exit_program(1);
2309 2310 2311
        }
    }

2312 2313 2314 2315 2316 2317
    if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
        av_log(NULL, AV_LOG_ERROR,
               "No input streams but output needs an input stream\n");
        exit_program(1);
    }

2318 2319 2320 2321 2322 2323 2324
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
        /* test if it already exists to avoid losing precious files */
        assert_file_overwrite(filename);

        /* open the file */
        if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
                              &oc->interrupt_callback,
2325
                              &of->opts)) < 0) {
2326
            print_error(filename, err);
2327
            exit_program(1);
2328
        }
2329 2330
    } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
        assert_file_overwrite(filename);
2331 2332

    if (o->mux_preload) {
2333
        av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2334 2335 2336 2337 2338 2339 2340 2341 2342 2343
    }
    oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);

    /* copy metadata */
    for (i = 0; i < o->nb_metadata_map; i++) {
        char *p;
        int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);

        if (in_file_index >= nb_input_files) {
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2344
            exit_program(1);
2345
        }
2346 2347 2348
        copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
                      in_file_index >= 0 ?
                      input_files[in_file_index]->ctx : NULL, o);
2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363
    }

    /* copy chapters */
    if (o->chapters_input_file >= nb_input_files) {
        if (o->chapters_input_file == INT_MAX) {
            /* copy chapters from the first input file that has them*/
            o->chapters_input_file = -1;
            for (i = 0; i < nb_input_files; i++)
                if (input_files[i]->ctx->nb_chapters) {
                    o->chapters_input_file = i;
                    break;
                }
        } else {
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
                   o->chapters_input_file);
2364
            exit_program(1);
2365 2366 2367
        }
    }
    if (o->chapters_input_file >= 0)
2368
        copy_chapters(input_files[o->chapters_input_file], of,
2369 2370 2371
                      !o->metadata_chapters_manual);

    /* copy global metadata by default */
2372
    if (!o->metadata_global_manual && nb_input_files){
2373 2374
        av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
                     AV_DICT_DONT_OVERWRITE);
2375 2376 2377 2378
        if(o->recording_time != INT64_MAX)
            av_dict_set(&oc->metadata, "duration", NULL, 0);
        av_dict_set(&oc->metadata, "creation_time", NULL, 0);
    }
2379
    if (!o->metadata_streams_manual)
2380
        for (i = of->ost_index; i < nb_output_streams; i++) {
2381 2382 2383 2384 2385
            InputStream *ist;
            if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
                continue;
            ist = input_streams[output_streams[i]->source_index];
            av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2386
            if (!output_streams[i]->stream_copy) {
2387
                av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2388 2389 2390
                if (ist->autorotate)
                    av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
            }
2391 2392
        }

2393 2394 2395 2396 2397 2398 2399 2400
    /* process manually set programs */
    for (i = 0; i < o->nb_program; i++) {
        const char *p = o->program[i].u.str;
        int progid = i+1;
        AVProgram *program;

        while(*p) {
            const char *p2 = av_get_token(&p, ":");
2401
            const char *to_dealloc = p2;
2402 2403 2404
            char *key;
            if (!p2)
                break;
2405

2406 2407 2408
            if(*p) p++;

            key = av_get_token(&p2, "=");
2409 2410 2411
            if (!key || !*p2) {
                av_freep(&to_dealloc);
                av_freep(&key);
2412
                break;
2413
            }
2414 2415 2416 2417
            p2++;

            if (!strcmp(key, "program_num"))
                progid = strtol(p2, NULL, 0);
2418 2419
            av_freep(&to_dealloc);
            av_freep(&key);
2420 2421 2422 2423 2424 2425 2426
        }

        program = av_new_program(oc, progid);

        p = o->program[i].u.str;
        while(*p) {
            const char *p2 = av_get_token(&p, ":");
2427
            const char *to_dealloc = p2;
2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453
            char *key;
            if (!p2)
                break;
            if(*p) p++;

            key = av_get_token(&p2, "=");
            if (!key) {
                av_log(NULL, AV_LOG_FATAL,
                       "No '=' character in program string %s.\n",
                       p2);
                exit_program(1);
            }
            if (!*p2)
                exit_program(1);
            p2++;

            if (!strcmp(key, "title")) {
                av_dict_set(&program->metadata, "title", p2, 0);
            } else if (!strcmp(key, "program_num")) {
            } else if (!strcmp(key, "st")) {
                int st_num = strtol(p2, NULL, 0);
                av_program_add_stream_index(oc, progid, st_num);
            } else {
                av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
                exit_program(1);
            }
2454 2455
            av_freep(&to_dealloc);
            av_freep(&key);
2456 2457 2458
        }
    }

2459 2460 2461 2462 2463
    /* process manually set metadata */
    for (i = 0; i < o->nb_metadata; i++) {
        AVDictionary **m;
        char type, *val;
        const char *stream_spec;
2464
        int index = 0, j, ret = 0;
2465 2466 2467 2468 2469

        val = strchr(o->metadata[i].u.str, '=');
        if (!val) {
            av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
                   o->metadata[i].u.str);
2470
            exit_program(1);
2471 2472 2473 2474 2475 2476
        }
        *val++ = 0;

        parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
        if (type == 's') {
            for (j = 0; j < oc->nb_streams; j++) {
2477
                ost = output_streams[nb_output_streams - oc->nb_streams + j];
2478 2479
                if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
                    av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2480 2481 2482
                    if (!strcmp(o->metadata[i].u.str, "rotate")) {
                        ost->rotate_overridden = 1;
                    }
2483
                } else if (ret < 0)
2484
                    exit_program(1);
2485 2486 2487 2488 2489 2490 2491 2492 2493 2494
            }
        }
        else {
            switch (type) {
            case 'g':
                m = &oc->metadata;
                break;
            case 'c':
                if (index < 0 || index >= oc->nb_chapters) {
                    av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2495
                    exit_program(1);
2496 2497 2498
                }
                m = &oc->chapters[index]->metadata;
                break;
2499 2500 2501 2502 2503 2504 2505
            case 'p':
                if (index < 0 || index >= oc->nb_programs) {
                    av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
                    exit_program(1);
                }
                m = &oc->programs[index]->metadata;
                break;
2506 2507
            default:
                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2508
                exit_program(1);
2509 2510 2511 2512 2513
            }
            av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
        }
    }

2514
    return 0;
2515 2516
}

2517
static int opt_target(void *optctx, const char *opt, const char *arg)
2518
{
2519
    OptionsContext *o = optctx;
2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
    static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };

    if (!strncmp(arg, "pal-", 4)) {
        norm = PAL;
        arg += 4;
    } else if (!strncmp(arg, "ntsc-", 5)) {
        norm = NTSC;
        arg += 5;
    } else if (!strncmp(arg, "film-", 5)) {
        norm = FILM;
        arg += 5;
    } else {
        /* Try to determine PAL/NTSC by peeking in the input files */
        if (nb_input_files) {
            int i, j, fr;
            for (j = 0; j < nb_input_files; j++) {
                for (i = 0; i < input_files[j]->nb_streams; i++) {
                    AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2539 2540
                    if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
                        !c->time_base.num)
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562
                        continue;
                    fr = c->time_base.den * 1000 / c->time_base.num;
                    if (fr == 25000) {
                        norm = PAL;
                        break;
                    } else if ((fr == 29970) || (fr == 23976)) {
                        norm = NTSC;
                        break;
                    }
                }
                if (norm != UNKNOWN)
                    break;
            }
        }
        if (norm != UNKNOWN)
            av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
    }

    if (norm == UNKNOWN) {
        av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
        av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
        av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2563
        exit_program(1);
2564 2565 2566 2567 2568 2569 2570 2571 2572
    }

    if (!strcmp(arg, "vcd")) {
        opt_video_codec(o, "c:v", "mpeg1video");
        opt_audio_codec(o, "c:a", "mp2");
        parse_option(o, "f", "vcd", options);

        parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
        parse_option(o, "r", frame_rates[norm], options);
2573
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2574

2575
        opt_default(NULL, "b:v", "1150000");
2576 2577 2578
        opt_default(NULL, "maxrate:v", "1150000");
        opt_default(NULL, "minrate:v", "1150000");
        opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2579

2580
        opt_default(NULL, "b:a", "224000");
2581 2582 2583
        parse_option(o, "ar", "44100", options);
        parse_option(o, "ac", "2", options);

2584 2585
        opt_default(NULL, "packetsize", "2324");
        opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600

        /* We have to offset the PTS, so that it is consistent with the SCR.
           SCR starts at 36000, but the first two packs contain only padding
           and the first pack from the other stream, respectively, may also have
           been written before.
           So the real data starts at SCR 36000+3*1200. */
        o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
    } else if (!strcmp(arg, "svcd")) {

        opt_video_codec(o, "c:v", "mpeg2video");
        opt_audio_codec(o, "c:a", "mp2");
        parse_option(o, "f", "svcd", options);

        parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
        parse_option(o, "r", frame_rates[norm], options);
2601
        parse_option(o, "pix_fmt", "yuv420p", options);
2602
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2603

2604
        opt_default(NULL, "b:v", "2040000");
2605 2606 2607
        opt_default(NULL, "maxrate:v", "2516000");
        opt_default(NULL, "minrate:v", "0"); // 1145000;
        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2608
        opt_default(NULL, "scan_offset", "1");
2609

2610
        opt_default(NULL, "b:a", "224000");
2611 2612
        parse_option(o, "ar", "44100", options);

2613
        opt_default(NULL, "packetsize", "2324");
2614 2615 2616 2617 2618 2619 2620 2621 2622

    } else if (!strcmp(arg, "dvd")) {

        opt_video_codec(o, "c:v", "mpeg2video");
        opt_audio_codec(o, "c:a", "ac3");
        parse_option(o, "f", "dvd", options);

        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
        parse_option(o, "r", frame_rates[norm], options);
2623
        parse_option(o, "pix_fmt", "yuv420p", options);
2624
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2625

2626
        opt_default(NULL, "b:v", "6000000");
2627 2628 2629
        opt_default(NULL, "maxrate:v", "9000000");
        opt_default(NULL, "minrate:v", "0"); // 1500000;
        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2630

2631 2632
        opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
        opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2633

2634
        opt_default(NULL, "b:a", "448000");
2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652
        parse_option(o, "ar", "48000", options);

    } else if (!strncmp(arg, "dv", 2)) {

        parse_option(o, "f", "dv", options);

        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
        parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
                          norm == PAL ? "yuv420p" : "yuv411p", options);
        parse_option(o, "r", frame_rates[norm], options);

        parse_option(o, "ar", "48000", options);
        parse_option(o, "ac", "2", options);

    } else {
        av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
        return AVERROR(EINVAL);
    }
2653

2654 2655
    av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
    av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2656

2657 2658 2659
    return 0;
}

2660
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2661 2662 2663 2664 2665 2666
{
    av_free (vstats_filename);
    vstats_filename = av_strdup (arg);
    return 0;
}

2667
static int opt_vstats(void *optctx, const char *opt, const char *arg)
2668 2669 2670 2671 2672
{
    char filename[40];
    time_t today2 = time(NULL);
    struct tm *today = localtime(&today2);

2673
    if (!today) { // maybe tomorrow
2674
        av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2675 2676
        exit_program(1);
    }
2677

2678 2679
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
             today->tm_sec);
2680
    return opt_vstats_file(NULL, opt, filename);
2681 2682
}

2683
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2684
{
2685
    OptionsContext *o = optctx;
2686 2687 2688
    return parse_option(o, "frames:v", arg, options);
}

2689
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2690
{
2691
    OptionsContext *o = optctx;
2692 2693 2694
    return parse_option(o, "frames:a", arg, options);
}

2695
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2696
{
2697
    OptionsContext *o = optctx;
2698 2699 2700
    return parse_option(o, "frames:d", arg, options);
}

2701 2702 2703
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
{
    int ret;
2704 2705
    AVDictionary *cbak = codec_opts;
    AVDictionary *fbak = format_opts;
2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720
    codec_opts = NULL;
    format_opts = NULL;

    ret = opt_default(NULL, opt, arg);

    av_dict_copy(&o->g->codec_opts , codec_opts, 0);
    av_dict_copy(&o->g->format_opts, format_opts, 0);
    av_dict_free(&codec_opts);
    av_dict_free(&format_opts);
    codec_opts = cbak;
    format_opts = fbak;

    return ret;
}

2721
static int opt_preset(void *optctx, const char *opt, const char *arg)
2722
{
2723
    OptionsContext *o = optctx;
2724 2725
    FILE *f=NULL;
    char filename[1000], line[1000], tmp_line[1000];
2726 2727 2728 2729 2730
    const char *codec_name = NULL;

    tmp_line[0] = *opt;
    tmp_line[1] = 0;
    MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2731 2732 2733 2734 2735 2736

    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
        if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
            av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
        }else
            av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2737
        exit_program(1);
2738
    }
2739 2740 2741 2742 2743 2744

    while (fgets(line, sizeof(line), f)) {
        char *key = tmp_line, *value, *endptr;

        if (strcspn(line, "#\n\r") == 0)
            continue;
2745
        av_strlcpy(tmp_line, line, sizeof(tmp_line));
2746 2747 2748
        if (!av_strtok(key,   "=",    &value) ||
            !av_strtok(value, "\r\n", &endptr)) {
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2749
            exit_program(1);
2750 2751 2752 2753 2754 2755 2756
        }
        av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);

        if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
        else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
        else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
        else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2757
        else if (opt_default_new(o, key, value) < 0) {
2758 2759
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
                   filename, line, key, value);
2760
            exit_program(1);
2761 2762 2763 2764 2765 2766 2767 2768
        }
    }

    fclose(f);

    return 0;
}

2769
static int opt_old2new(void *optctx, const char *opt, const char *arg)
2770
{
2771
    OptionsContext *o = optctx;
2772 2773 2774 2775
    char *s = av_asprintf("%s:%c", opt + 1, *opt);
    int ret = parse_option(o, s, arg, options);
    av_free(s);
    return ret;
2776 2777
}

2778
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2779
{
2780
    OptionsContext *o = optctx;
2781 2782 2783 2784 2785

    if(!strcmp(opt, "ab")){
        av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
        return 0;
    } else if(!strcmp(opt, "b")){
2786
        av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2787 2788
        av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
        return 0;
2789
    }
2790 2791
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
    return 0;
2792 2793
}

2794
static int opt_qscale(void *optctx, const char *opt, const char *arg)
2795
{
2796
    OptionsContext *o = optctx;
2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808
    char *s;
    int ret;
    if(!strcmp(opt, "qscale")){
        av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
        return parse_option(o, "q:v", arg, options);
    }
    s = av_asprintf("q%s", opt + 6);
    ret = parse_option(o, s, arg, options);
    av_free(s);
    return ret;
}

2809
static int opt_profile(void *optctx, const char *opt, const char *arg)
2810
{
2811
    OptionsContext *o = optctx;
2812 2813
    if(!strcmp(opt, "profile")){
        av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2814 2815
        av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
        return 0;
2816
    }
2817 2818
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
    return 0;
2819 2820
}

2821
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2822
{
2823
    OptionsContext *o = optctx;
2824 2825 2826
    return parse_option(o, "filter:v", arg, options);
}

2827
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2828
{
2829
    OptionsContext *o = optctx;
2830 2831 2832
    return parse_option(o, "filter:a", arg, options);
}

2833
static int opt_vsync(void *optctx, const char *opt, const char *arg)
2834 2835 2836 2837
{
    if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
    else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
    else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2838
    else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2839 2840 2841 2842 2843 2844

    if (video_sync_method == VSYNC_AUTO)
        video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
    return 0;
}

2845
static int opt_timecode(void *optctx, const char *opt, const char *arg)
2846
{
2847
    OptionsContext *o = optctx;
2848 2849 2850
    char *tcr = av_asprintf("timecode=%s", arg);
    int ret = parse_option(o, "metadata:g", tcr, options);
    if (ret >= 0)
2851
        ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2852
    av_free(tcr);
2853 2854 2855
    return 0;
}

2856
static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2857
{
2858
    OptionsContext *o = optctx;
2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870
    char layout_str[32];
    char *stream_str;
    char *ac_str;
    int ret, channels, ac_str_size;
    uint64_t layout;

    layout = av_get_channel_layout(arg);
    if (!layout) {
        av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
        return AVERROR(EINVAL);
    }
    snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2871
    ret = opt_default_new(o, opt, layout_str);
2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891
    if (ret < 0)
        return ret;

    /* set 'ac' option based on channel layout */
    channels = av_get_channel_layout_nb_channels(layout);
    snprintf(layout_str, sizeof(layout_str), "%d", channels);
    stream_str = strchr(opt, ':');
    ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
    ac_str = av_mallocz(ac_str_size);
    if (!ac_str)
        return AVERROR(ENOMEM);
    av_strlcpy(ac_str, "ac", 3);
    if (stream_str)
        av_strlcat(ac_str, stream_str, ac_str_size);
    ret = parse_option(o, ac_str, layout_str, options);
    av_free(ac_str);

    return ret;
}

2892
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2893
{
2894
    OptionsContext *o = optctx;
2895 2896 2897
    return parse_option(o, "q:a", arg, options);
}

2898
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2899
{
2900
    GROW_ARRAY(filtergraphs, nb_filtergraphs);
2901 2902
    if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
        return AVERROR(ENOMEM);
2903 2904 2905 2906
    filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
    filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
    if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
        return AVERROR(ENOMEM);
2907 2908 2909

    input_stream_potentially_available = 1;

2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923
    return 0;
}

static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
{
    uint8_t *graph_desc = read_file(arg);
    if (!graph_desc)
        return AVERROR(EINVAL);

    GROW_ARRAY(filtergraphs, nb_filtergraphs);
    if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
        return AVERROR(ENOMEM);
    filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
    filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2924 2925 2926

    input_stream_potentially_available = 1;

2927 2928 2929
    return 0;
}

2930
void show_help_default(const char *opt, const char *arg)
2931
{
2932
    /* per-file options have at least one of those set */
2933
    const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2934 2935
    int show_advanced = 0, show_avoptions = 0;

2936
    if (opt && *opt) {
2937 2938 2939 2940 2941 2942 2943
        if (!strcmp(opt, "long"))
            show_advanced = 1;
        else if (!strcmp(opt, "full"))
            show_advanced = show_avoptions = 1;
        else
            av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
    }
2944

2945
    show_usage();
2946 2947 2948 2949 2950

    printf("Getting help:\n"
           "    -h      -- print basic options\n"
           "    -h long -- print more options\n"
           "    -h full -- print all options (including all format and codec specific options, very long)\n"
2951
           "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2952 2953 2954
           "    See man %s for detailed description of the options.\n"
           "\n", program_name);

2955
    show_help_options(options, "Print help / information / capabilities:",
2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
                      OPT_EXIT, 0, 0);

    show_help_options(options, "Global options (affect whole program "
                      "instead of just one file:",
                      0, per_file | OPT_EXIT | OPT_EXPERT, 0);
    if (show_advanced)
        show_help_options(options, "Advanced global options:", OPT_EXPERT,
                          per_file | OPT_EXIT, 0);

    show_help_options(options, "Per-file main options:", 0,
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
                      OPT_EXIT, per_file);
2968
    if (show_advanced)
2969 2970
        show_help_options(options, "Advanced per-file options:",
                          OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2971

2972
    show_help_options(options, "Video options:",
2973
                      OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2974 2975
    if (show_advanced)
        show_help_options(options, "Advanced Video options:",
2976
                          OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2977

2978
    show_help_options(options, "Audio options:",
2979
                      OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2980 2981
    if (show_advanced)
        show_help_options(options, "Advanced Audio options:",
2982
                          OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2983
    show_help_options(options, "Subtitle options:",
2984
                      OPT_SUBTITLE, 0, 0);
2985
    printf("\n");
2986 2987 2988 2989 2990

    if (show_avoptions) {
        int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
        show_help_children(avcodec_get_class(), flags);
        show_help_children(avformat_get_class(), flags);
2991
#if CONFIG_SWSCALE
2992
        show_help_children(sws_get_class(), flags);
2993
#endif
2994
        show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2995
        show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2996
    }
2997 2998 2999 3000
}

void show_usage(void)
{
3001 3002 3003
    av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
    av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
    av_log(NULL, AV_LOG_INFO, "\n");
3004 3005
}

3006 3007 3008 3009 3010 3011
enum OptGroup {
    GROUP_OUTFILE,
    GROUP_INFILE,
};

static const OptionGroupDef groups[] = {
3012 3013
    [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
    [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024
};

static int open_files(OptionGroupList *l, const char *inout,
                      int (*open_file)(OptionsContext*, const char*))
{
    int i, ret;

    for (i = 0; i < l->nb_groups; i++) {
        OptionGroup *g = &l->groups[i];
        OptionsContext o;

3025
        init_options(&o);
3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036
        o.g = g;

        ret = parse_optgroup(&o, g);
        if (ret < 0) {
            av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
                   "%s.\n", inout, g->arg);
            return ret;
        }

        av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
        ret = open_file(&o, g->arg);
3037
        uninit_options(&o);
3038 3039 3040 3041 3042
        if (ret < 0) {
            av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
                   inout, g->arg);
            return ret;
        }
3043
        av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3044 3045 3046 3047 3048
    }

    return 0;
}

3049
int ffmpeg_parse_options(int argc, char **argv)
3050 3051 3052 3053 3054 3055 3056 3057
{
    OptionParseContext octx;
    uint8_t error[128];
    int ret;

    memset(&octx, 0, sizeof(octx));

    /* split the commandline into an internal representation */
3058 3059
    ret = split_commandline(&octx, argc, argv, options, groups,
                            FF_ARRAY_ELEMS(groups));
3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078
    if (ret < 0) {
        av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
        goto fail;
    }

    /* apply global options */
    ret = parse_optgroup(NULL, &octx.global_opts);
    if (ret < 0) {
        av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
        goto fail;
    }

    /* open input files */
    ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
    if (ret < 0) {
        av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
        goto fail;
    }

3079
    /* create the complex filtergraphs */
3080
    ret = init_complex_filters();
3081
    if (ret < 0) {
3082
        av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3083 3084 3085
        goto fail;
    }

3086 3087 3088 3089 3090 3091 3092
    /* open output files */
    ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
    if (ret < 0) {
        av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
        goto fail;
    }

3093 3094 3095 3096 3097 3098 3099
    /* configure the complex filtergraphs */
    ret = configure_complex_filters();
    if (ret < 0) {
        av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
        goto fail;
    }

3100 3101 3102 3103 3104 3105 3106 3107
fail:
    uninit_parse_context(&octx);
    if (ret < 0) {
        av_strerror(ret, error, sizeof(error));
        av_log(NULL, AV_LOG_FATAL, "%s\n", error);
    }
    return ret;
}
3108

3109
static int opt_progress(void *optctx, const char *opt, const char *arg)
3110 3111 3112 3113 3114 3115 3116 3117
{
    AVIOContext *avio = NULL;
    int ret;

    if (!strcmp(arg, "-"))
        arg = "pipe:";
    ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
    if (ret < 0) {
3118
        av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3119 3120 3121 3122 3123 3124 3125
               arg, av_err2str(ret));
        return ret;
    }
    progress_avio = avio;
    return 0;
}

3126 3127 3128 3129
#define OFFSET(x) offsetof(OptionsContext, x)
const OptionDef options[] = {
    /* main options */
#include "cmdutils_common_opts.h"
3130 3131
    { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
                        OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3132 3133 3134
        "force format", "fmt" },
    { "y",              OPT_BOOL,                                    {              &file_overwrite },
        "overwrite output files" },
3135
    { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3136
        "never overwrite output files" },
3137 3138
    { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
        "Ignore unknown stream types" },
3139 3140
    { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
        "Copy unknown stream types" },
3141 3142
    { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
                        OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3143
        "codec name", "codec" },
3144 3145
    { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
                        OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3146
        "codec name", "codec" },
3147 3148
    { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3149
        "preset name", "preset" },
3150 3151
    { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
                        OPT_OUTPUT,                                  { .func_arg = opt_map },
3152 3153
        "set input stream mapping",
        "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3154
    { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3155
        "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3156 3157
    { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3158 3159
        "set metadata information of outfile from infile",
        "outfile[,metadata]:infile[,metadata]" },
3160 3161
    { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
                        OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3162
        "set chapters mapping", "input_file_index" },
3163 3164
    { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
                        OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3165 3166
        "record or transcode \"duration\" seconds of audio/video",
        "duration" },
3167
    { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3168
        "record or transcode stop time", "time_stop" },
3169
    { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3170
        "set the limit file size in bytes", "limit_size" },
3171 3172
    { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
                        OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3173
        "set the start time offset", "time_off" },
3174 3175 3176
    { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
                        OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time_eof) },
        "set the start time offset relative to EOF", "time_off" },
3177 3178 3179
    { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
                        OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
        "enable/disable seeking by timestamp with -ss" },
3180 3181 3182
    { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
                        OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
        "enable/disable accurate seeking with -ss" },
3183 3184
    { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
                        OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3185
        "set the input ts offset", "time_off" },
3186 3187
    { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
                        OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3188
        "set the input ts scale", "scale" },
3189
    { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3190
        "set the recording timestamp ('now' to set the current time)", "time" },
3191
    { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3192
        "add metadata", "string=string" },
3193 3194
    { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
        "add program with specified streams", "title=string:st=number..." },
3195 3196
    { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
                        OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3197
        "set the number of data frames to output", "number" },
3198 3199
    { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
        "add timings for benchmarking" },
3200
    { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3201
      "add timings for each task" },
3202
    { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3203
      "write program-readable progress information", "url" },
3204
    { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3205
      "enable or disable interaction on standard input" },
3206
    { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3207 3208 3209 3210 3211
        "set max runtime in seconds", "limit" },
    { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
        "dump each input packet" },
    { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
        "when dumping packets, also dump the payload" },
3212 3213
    { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
                        OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3214
        "read input at native frame rate", "" },
3215
    { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3216 3217
        "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
        "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3218
    { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3219
        "video sync method", "" },
3220 3221
    { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
        "frame drop threshold", "" },
3222 3223 3224 3225 3226 3227
    { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
        "audio sync method", "" },
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
        "audio drift threshold", "threshold" },
    { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
        "copy timestamps" },
3228 3229
    { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
        "shift input timestamps to start at 0 when using copyts" },
3230 3231
    { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
        "copy input stream time base when stream copying", "mode" },
3232 3233
    { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
                        OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3234
        "finish encoding within shortest input" },
3235 3236 3237
    { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off = OFFSET(apad) },
        "audio pad", "" },
3238 3239
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
        "timestamp discontinuity delta threshold", "threshold" },
3240 3241
    { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
        "timestamp error delta threshold", "threshold" },
3242
    { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3243
        "exit on error", "error" },
3244 3245
    { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
        "abort on the specified condition flags", "flags" },
3246 3247
    { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3248
        "copy initial non-keyframes" },
3249
    { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3250
        "copy or discard frames before start time" },
3251
    { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3252
        "set the number of frames to output", "number" },
3253
    { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3254
                        OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3255
        "force codec tag/fourcc", "fourcc/tag" },
3256 3257
    { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
                        OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3258
        "use fixed quality scale (VBR)", "q" },
3259 3260
    { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
                        OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3261
        "use fixed quality scale (VBR)", "q" },
3262
    { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3263
        "set profile", "profile" },
3264
    { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3265
        "set stream filtergraph", "filter_graph" },
3266 3267
    { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
        "read stream filtergraph description from a file", "filename" },
3268
    { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3269
        "reinit filtergraph on input parameter changes", "" },
3270 3271
    { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
        "create a complex filtergraph", "graph_description" },
3272 3273
    { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
        "create a complex filtergraph", "graph_description" },
3274 3275
    { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
        "read complex filtergraph description from a file", "filename" },
3276 3277
    { "stats",          OPT_BOOL,                                    { &print_stats },
        "print progress report during encoding", },
3278 3279
    { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
                        OPT_OUTPUT,                                  { .func_arg = opt_attach },
3280
        "add an attachment to the output file", "filename" },
3281 3282
    { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
                         OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3283
        "extract an attachment into a file", "filename" },
3284
    { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3285
                        OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3286 3287
    { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
        "print timestamp debugging info" },
3288 3289
    { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
        "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3290 3291 3292
    { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
                        OPT_INPUT,                                   { .off = OFFSET(discard) },
        "discard", "" },
3293 3294 3295
    { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
        "disposition", "" },
3296 3297 3298
    { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
                                                                     { .off = OFFSET(thread_queue_size) },
        "set the maximum number of queued packets from the demuxer" },
3299 3300

    /* video options */
3301
    { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3302
        "set the number of video frames to output", "number" },
3303 3304
    { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
                      OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3305
        "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3306
    { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3307
                      OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3308
        "set frame size (WxH or abbreviation)", "size" },
3309 3310
    { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3311
        "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3312 3313
    { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                      OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3314
        "set pixel format", "format" },
3315 3316 3317 3318
    { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
        "set the number of bits per raw sample", "number" },
    { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
        "deprecated use -g 1" },
3319
    { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3320
        "disable video" },
3321 3322
    { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3323
        "rate control override for specific intervals", "override" },
3324 3325
    { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
                      OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3326
        "force video codec ('copy' to copy stream)", "codec" },
3327 3328 3329 3330
    { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
        "Removed" },
    { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
        "Removed" },
3331
    { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3332
        "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3333
    { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3334
        "select the pass number (1 to 3)", "n" },
3335 3336
    { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3337
        "select two pass log file name prefix", "prefix" },
3338
    { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3339
        "this option is deprecated, use the yadif filter instead" },
3340 3341
    { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
        "calculate PSNR of compressed frames" },
3342
    { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3343
        "dump video coding statistics to file" },
3344
    { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3345
        "dump video coding statistics to file", "file" },
3346
    { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3347
        "set video filters", "filter_graph" },
3348 3349
    { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3350
        "specify intra matrix coeffs", "matrix" },
3351 3352
    { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3353
        "specify inter matrix coeffs", "matrix" },
3354 3355 3356
    { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
        "specify intra matrix coeffs", "matrix" },
3357
    { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3358
                      OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3359
        "top=1/bottom=0/auto=-1 field first", "" },
3360
    { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3361
                      OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3362 3363 3364
        "force video tag/fourcc", "fourcc/tag" },
    { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
        "show QP histogram" },
3365 3366
    { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3367
        "force the selected framerate, disable the best supported framerate selection" },
3368 3369
    { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
                      OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3370
        "set the value of an outfile streamid", "streamIndex:value" },
3371 3372
    { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
                          OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3373
        "force key frames at specified timestamps", "timestamps" },
3374 3375
    { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
        "audio bitrate (please use -b:a)", "bitrate" },
3376
    { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3377
        "video bitrate (please use -b:v)", "bitrate" },
3378 3379 3380 3381 3382
    { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
                          OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
        "use HW accelerated decoding", "hwaccel name" },
    { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
                          OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3383
        "select a device for HW acceleration", "devicename" },
3384 3385 3386
    { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
                          OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
        "select output format used with HW accelerated decoding", "format" },
3387 3388
#if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
    { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3389
#endif
3390 3391
    { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
        "show available HW acceleration methods" },
3392 3393 3394
    { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
                          OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
        "automatically insert correct rotate filters" },
3395 3396
    { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT,                        { &hwaccel_lax_profile_check},
        "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3397 3398

    /* audio options */
3399
    { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3400
        "set the number of audio frames to output", "number" },
3401
    { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3402
        "set audio quality (codec-specific)", "quality", },
3403 3404
    { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
                        OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3405
        "set audio sampling rate (in Hz)", "rate" },
3406 3407
    { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
                        OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3408
        "set number of audio channels", "channels" },
3409
    { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3410
        "disable audio" },
3411 3412
    { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
                        OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3413
        "force audio codec ('copy' to copy stream)", "codec" },
3414
    { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3415
                        OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3416 3417 3418
        "force audio tag/fourcc", "fourcc/tag" },
    { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
        "change audio volume (256=normal)" , "volume" },
3419 3420
    { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
                        OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3421
        "set sample format", "format" },
3422 3423
    { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
                        OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3424
        "set channel layout", "layout" },
3425
    { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3426
        "set audio filters", "filter_graph" },
3427
    { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3428
      "set the maximum number of channels to try to guess the channel layout" },
3429 3430

    /* subtitle options */
3431
    { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3432
        "disable subtitle" },
3433
    { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3434
        "force subtitle codec ('copy' to copy stream)", "codec" },
3435
    { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3436
        , "force subtitle tag/fourcc", "fourcc/tag" },
3437
    { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3438
        "fix subtitles duration" },
3439
    { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3440
        "set canvas size (WxH or abbreviation)", "size" },
3441 3442

    /* grab options */
3443
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3444
        "deprecated, use -channel", "channel" },
3445
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3446
        "deprecated, use -standard", "standard" },
3447
    { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3448 3449

    /* muxer options */
3450
    { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3451
        "set the maximum demux-decode delay", "seconds" },
3452
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3453
        "set the initial demux-decode delay", "seconds" },
3454 3455
    { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
        "override the options from ffserver", "" },
3456
    { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3457
        "specify a file in which to print sdp information", "file" },
3458

3459
    { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3460
        "A comma-separated list of bitstream filters", "bitstream_filters" },
3461
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3462
        "deprecated", "audio bitstream_filters" },
3463
    { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3464 3465
        "deprecated", "video bitstream_filters" },

3466
    { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3467
        "set the audio options to the indicated preset", "preset" },
3468
    { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3469
        "set the video options to the indicated preset", "preset" },
3470
    { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3471
        "set the subtitle options to the indicated preset", "preset" },
3472
    { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3473
        "set options from indicated preset file", "filename" },
3474
    /* data codec support */
3475
    { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3476
        "force data codec ('copy' to copy stream)", "codec" },
3477
    { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3478
        "disable data" },
3479

3480 3481 3482 3483 3484
#if CONFIG_VAAPI
    { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
        "set VAAPI hardware device (DRM path or X11 display name)", "device" },
#endif

3485 3486
    { NULL, },
};