ffmpeg_opt.c 122 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 44 45 46 47 48 49 50 51
#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"

#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)\
52
            exit_program(1);\
53 54 55
    }\
}

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

66
const HWAccel hwaccels[] = {
67 68
#if HAVE_VDPAU_X11
    { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
69
#endif
70
#if HAVE_DXVA2_LIB
71
    { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
72 73 74
#endif
#if CONFIG_VDA
    { "vda",   vda_init,   HWACCEL_VDA,   AV_PIX_FMT_VDA },
75
#endif
76 77 78
    { 0 },
};

79
char *vstats_filename;
80
char *sdp_filename;
81 82 83

float audio_drift_threshold = 0.1;
float dts_delta_threshold   = 10;
84
float dts_error_threshold   = 3600*30;
85 86 87 88 89 90

int audio_volume      = 256;
int audio_sync_method = 0;
int video_sync_method = VSYNC_AUTO;
int do_deinterlace    = 0;
int do_benchmark      = 0;
91
int do_benchmark_all  = 0;
92 93 94
int do_hex_dump       = 0;
int do_pkt_dump       = 0;
int copy_ts           = 0;
95
int start_at_zero     = 0;
96 97
int copy_tb           = -1;
int debug_ts          = 0;
98
int exit_on_error     = 0;
99
int print_stats       = -1;
100
int qp_hist           = 0;
101 102
int stdin_interaction = 1;
int frame_bits_per_raw_sample = 0;
103
float max_error_rate  = 2.0/3;
104

105 106

static int intra_only         = 0;
107
static int file_overwrite     = 0;
108 109
static int no_file_overwrite  = 0;
static int do_psnr            = 0;
110
static int input_sync;
111
static int override_ffserver  = 0;
112

113
static void uninit_options(OptionsContext *o)
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
{
    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);
140
    av_freep(&o->audio_channel_maps);
141
    av_freep(&o->streamid_map);
142
    av_freep(&o->attachments);
143
}
144

145
static void init_options(OptionsContext *o)
146
{
147 148
    memset(o, 0, sizeof(*o));

149
    o->stop_time = INT64_MAX;
150
    o->mux_max_delay  = 0.7;
151
    o->start_time     = AV_NOPTS_VALUE;
152
    o->recording_time = INT64_MAX;
153 154
    o->limit_filesize = UINT64_MAX;
    o->chapters_input_file = INT_MAX;
155
    o->accurate_seek  = 1;
156 157
}

158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
/* 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;
}

176 177
static int opt_sameq(void *optctx, const char *opt, const char *arg)
{
178 179 180 181 182
    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);
183 184
}

185
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
186 187
{
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
188
    return opt_default(optctx, "channel", arg);
189
}
190

191
static int opt_video_standard(void *optctx, const char *opt, const char *arg)
192 193
{
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
194
    return opt_default(optctx, "standard", arg);
195 196
}

197
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
198
{
199
    OptionsContext *o = optctx;
200 201 202
    return parse_option(o, "codec:a", arg, options);
}

203
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
204
{
205
    OptionsContext *o = optctx;
206 207 208
    return parse_option(o, "codec:v", arg, options);
}

209
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
210
{
211
    OptionsContext *o = optctx;
212 213 214
    return parse_option(o, "codec:s", arg, options);
}

215
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
216
{
217
    OptionsContext *o = optctx;
218 219 220
    return parse_option(o, "codec:d", arg, options);
}

221
static int opt_map(void *optctx, const char *opt, const char *arg)
222
{
223
    OptionsContext *o = optctx;
224 225
    StreamMap *m = NULL;
    int i, negative = 0, file_idx;
226
    int sync_file_idx = -1, sync_stream_idx = 0;
227 228 229 230 231 232 233 234
    char *p, *sync;
    char *map;

    if (*arg == '-') {
        negative = 1;
        arg++;
    }
    map = av_strdup(arg);
235 236
    if (!map)
        return AVERROR(ENOMEM);
237 238 239 240 241 242 243

    /* 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);
244
            exit_program(1);
245 246 247 248 249 250 251 252 253 254 255 256
        }
        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);
257
            exit_program(1);
258 259 260 261 262 263 264
        }
    }


    if (map[0] == '[') {
        /* this mapping refers to lavfi output */
        const char *c = map + 1;
265
        GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
266 267 268 269
        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);
270
            exit_program(1);
271 272 273 274 275
        }
    } else {
        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);
276
            exit_program(1);
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
        }
        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;
293
                GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
                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) {
        av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
311
        exit_program(1);
312 313 314 315 316 317
    }

    av_freep(&map);
    return 0;
}

318
static int opt_attach(void *optctx, const char *opt, const char *arg)
319
{
320
    OptionsContext *o = optctx;
321
    GROW_ARRAY(o->attachments, o->nb_attachments);
322 323 324 325
    o->attachments[o->nb_attachments - 1] = arg;
    return 0;
}

326
static int opt_map_channel(void *optctx, const char *opt, const char *arg)
327
{
328
    OptionsContext *o = optctx;
329 330 331 332
    int n;
    AVStream *st;
    AudioChannelMap *m;

333
    GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
    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");
353
        exit_program(1);
354 355 356 357 358 359 360 361 362
    }

    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);
363
        exit_program(1);
364 365 366 367 368
    }
    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);
369
        exit_program(1);
370 371 372 373 374
    }
    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);
375
        exit_program(1);
376 377 378 379
    }
    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);
380
        exit_program(1);
381 382 383 384
    }
    return 0;
}

385 386 387 388 389 390 391
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
{
    av_free(sdp_filename);
    sdp_filename = av_strdup(arg);
    return 0;
}

392
/**
393
 * Parse a metadata specifier passed as 'arg' parameter.
394
 * @param arg  metadata string to parse
395 396 397 398 399 400 401 402 403 404 405 406 407 408
 * @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);
409
                exit_program(1);
410 411 412 413 414 415 416 417 418 419
            }
            *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);
420
            exit_program(1);
421 422 423 424 425 426 427 428
        }
    } else
        *type = 'g';
}

static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
{
    AVDictionary **meta_in = NULL;
429
    AVDictionary **meta_out = NULL;
430 431 432 433 434 435 436 437
    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);

438 439 440 441 442 443 444 445 446 447
    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;
    }

448 449 450 451 452 453 454
    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;

455 456 457 458
    /* ic is NULL when just disabling automatic mappings */
    if (!ic)
        return 0;

459 460 461 462
#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));\
463
        exit_program(1);\
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
    }

#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;\
479
        case 's':\
480
            break; /* handled separately below */ \
481 482 483 484 485 486 487 488 489 490 491 492 493
        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)
494
                exit_program(1);
495 496 497
        }
        if (!meta_in) {
            av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
498
            exit_program(1);
499 500 501 502 503 504 505 506 507
        }
    }

    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)
508
                exit_program(1);
509 510 511 512 513 514 515
        }
    } else
        av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);

    return 0;
}

516
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
517
{
518
    OptionsContext *o = optctx;
519 520 521
    char buf[128];
    int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
    struct tm time = *gmtime((time_t*)&recording_timestamp);
522
    if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
523
        return -1;
524 525 526 527 528 529 530
    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;
}

531 532
static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
{
533
    const AVCodecDescriptor *desc;
534 535 536 537 538 539
    const char *codec_string = encoder ? "encoder" : "decoder";
    AVCodec *codec;

    codec = encoder ?
        avcodec_find_encoder_by_name(name) :
        avcodec_find_decoder_by_name(name);
540 541 542 543 544 545 546 547 548

    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);
    }

549 550
    if (!codec) {
        av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
551
        exit_program(1);
552 553 554
    }
    if (codec->type != type) {
        av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
555
        exit_program(1);
556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
    }
    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);
}

573 574
/* Add all the streams from the given input file to the global
 * list of input streams. */
575 576
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
{
577
    int i, ret;
578 579 580 581 582

    for (i = 0; i < ic->nb_streams; i++) {
        AVStream *st = ic->streams[i];
        AVCodecContext *dec = st->codec;
        InputStream *ist = av_mallocz(sizeof(*ist));
583
        char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
584 585
        char *codec_tag = NULL;
        char *next;
586 587
        char *discard_str = NULL;
        const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
588 589

        if (!ist)
590
            exit_program(1);
591

592
        GROW_ARRAY(input_streams, nb_input_streams);
593 594 595 596 597 598 599 600 601 602
        input_streams[nb_input_streams - 1] = ist;

        ist->st = st;
        ist->file_index = nb_input_files;
        ist->discard = 1;
        st->discard  = AVDISCARD_ALL;

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

603 604 605 606 607 608 609 610
        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;
        }

611
        ist->dec = choose_decoder(o, ic, st);
612
        ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
613

614 615 616
        ist->reinit_filters = -1;
        MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);

617 618 619 620 621 622 623 624
        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);
        }

625 626
        ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;

627 628 629 630 631 632 633 634 635 636 637 638
        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);
        }

639 640
        switch (dec->codec_type) {
        case AVMEDIA_TYPE_VIDEO:
641 642
            if(!ist->dec)
                ist->dec = avcodec_find_decoder(dec->codec_id);
643
            if (av_codec_get_lowres(dec)) {
644 645 646
                dec->flags |= CODEC_FLAG_EMU_EDGE;
            }

647 648 649
            ist->resample_height  = ist->dec_ctx->height;
            ist->resample_width   = ist->dec_ctx->width;
            ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
650 651 652 653 654 655

            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);
656
                exit_program(1);
657 658
            }

659 660 661
            ist->top_field_first = -1;
            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);

662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
            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);
            }
695
            ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
696

697 698
            break;
        case AVMEDIA_TYPE_AUDIO:
699 700
            ist->guess_layout_max = INT_MAX;
            MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
701 702
            guess_input_channel_layout(ist);

703 704 705 706
            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;
707 708 709

            break;
        case AVMEDIA_TYPE_DATA:
710 711
        case AVMEDIA_TYPE_SUBTITLE: {
            char *canvas_size = NULL;
712 713
            if(!ist->dec)
                ist->dec = avcodec_find_decoder(dec->codec_id);
714
            MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
715 716
            MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
            if (canvas_size &&
717
                av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
718
                av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
719
                exit_program(1);
720
            }
721
            break;
722
        }
723 724 725 726 727 728 729 730 731 732 733
        case AVMEDIA_TYPE_ATTACHMENT:
        case AVMEDIA_TYPE_UNKNOWN:
            break;
        default:
            abort();
        }
    }
}

static void assert_file_overwrite(const char *filename)
{
734
    if (file_overwrite && no_file_overwrite) {
735 736 737 738
        fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
        exit_program(1);
    }

739 740 741
    if (!file_overwrite) {
        const char *proto_name = avio_find_protocol_name(filename);
        if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
742
            if (stdin_interaction && !no_file_overwrite) {
743 744
                fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
                fflush(stderr);
745 746
                term_exit();
                signal(SIGINT, SIG_DFL);
747
                if (!read_yesno()) {
748
                    av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
749
                    exit_program(1);
750
                }
751
                term_init();
752 753
            }
            else {
754
                av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
755
                exit_program(1);
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
            }
        }
    }
}

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);
777
        exit_program(1);
778 779 780 781 782 783 784
    }

    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);
785
        exit_program(1);
786 787 788 789 790 791 792
    }

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

793
static int open_input_file(OptionsContext *o, const char *filename)
794
{
795
    InputFile *f;
796 797 798 799 800
    AVFormatContext *ic;
    AVInputFormat *file_iformat = NULL;
    int err, i, ret;
    int64_t timestamp;
    AVDictionary **opts;
801 802
    AVDictionary *unused_opts = NULL;
    AVDictionaryEntry *e = NULL;
803
    int orig_nb_streams;                     // number of streams before avformat_find_stream_info
804 805 806
    char *   video_codec_name = NULL;
    char *   audio_codec_name = NULL;
    char *subtitle_codec_name = NULL;
807
    char *    data_codec_name = NULL;
808
    int scan_all_pmts_set = 0;
809 810 811 812

    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);
813
            exit_program(1);
814 815 816 817 818 819
        }
    }

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

820 821
    stdin_interaction &= strncmp(filename, "pipe:", 5) &&
                         strcmp(filename, "/dev/stdin");
822 823 824 825 826

    /* get default parameters from command line */
    ic = avformat_alloc_context();
    if (!ic) {
        print_error(filename, AVERROR(ENOMEM));
827
        exit_program(1);
828 829
    }
    if (o->nb_audio_sample_rate) {
830
        av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
831 832 833 834 835 836 837 838
    }
    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)) {
839
            av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
840 841 842 843 844 845 846 847
        }
    }
    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)) {
848
            av_dict_set(&o->g->format_opts, "framerate",
849 850 851 852
                        o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
        }
    }
    if (o->nb_frame_sizes) {
853
        av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
854 855
    }
    if (o->nb_frame_pix_fmts)
856
        av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
857

858 859 860 861
    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");

862 863 864 865 866 867
    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;
868 869
    ic->data_codec_id    = data_codec_name ?
        find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
870 871 872 873 874 875 876

    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));
877 878
    if (data_codec_name)
        av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
879

880 881 882
    ic->flags |= AVFMT_FLAG_NONBLOCK;
    ic->interrupt_callback = int_cb;

883 884 885 886
    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;
    }
887
    /* open the input file with generic avformat function */
888
    err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
889 890
    if (err < 0) {
        print_error(filename, err);
891
        exit_program(1);
892
    }
893 894
    if (scan_all_pmts_set)
        av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
895
    remove_avoptions(&o->g->format_opts, o->g->codec_opts);
896
    assert_avoptions(o->g->format_opts);
897 898 899 900 901 902

    /* 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 */
903
    opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
904 905 906 907 908 909 910
    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);
911 912 913 914
        if (ic->nb_streams == 0) {
            avformat_close_input(&ic);
            exit_program(1);
        }
915 916
    }

917
    timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
918 919 920 921 922
    /* add the stream start time */
    if (ic->start_time != AV_NOPTS_VALUE)
        timestamp += ic->start_time;

    /* if seeking requested, we execute it */
923
    if (o->start_time != AV_NOPTS_VALUE) {
924
        ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
925 926 927 928 929 930 931 932 933 934 935 936
        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);

937
    GROW_ARRAY(input_files, nb_input_files);
938 939
    f = av_mallocz(sizeof(*f));
    if (!f)
940
        exit_program(1);
941
    input_files[nb_input_files - 1] = f;
942

943 944
    f->ctx        = ic;
    f->ist_index  = nb_input_streams - ic->nb_streams;
945
    f->start_time = o->start_time;
946
    f->recording_time = o->recording_time;
947
    f->input_ts_offset = o->input_ts_offset;
948
    f->ts_offset  = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
949 950
    f->nb_streams = ic->nb_streams;
    f->rate_emu   = o->rate_emu;
951
    f->accurate_seek = o->accurate_seek;
952

953 954 955 956
    /* 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;
957
        while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
958 959 960 961 962 963 964 965 966
                                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);
967 968 969 970
        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)
971
            continue;
972 973


974 975 976 977 978
        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);
979
            exit_program(1);
980 981 982 983 984 985 986 987 988 989 990
        }

        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);

991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
    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);

    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");
1017
        exit_program(1);
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
    }

    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)
{
1030
    int i, ret = -1;
1031 1032 1033 1034 1035 1036
    char filename[1000];
    const char *base[3] = { getenv("AVCONV_DATADIR"),
                            getenv("HOME"),
                            AVCONV_DATADIR,
                            };

1037
    for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1038 1039 1040 1041 1042 1043 1044
        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);
        }
1045
        if (ret < 0) {
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
            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;
    }
}

1071
static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1072 1073 1074 1075 1076 1077 1078
{
    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;
1079
    int i;
1080 1081 1082

    if (!st) {
        av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1083
        exit_program(1);
1084 1085 1086 1087 1088
    }

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

1089
    GROW_ARRAY(output_streams, nb_output_streams);
1090
    if (!(ost = av_mallocz(sizeof(*ost))))
1091
        exit_program(1);
1092 1093
    output_streams[nb_output_streams - 1] = ost;

1094
    ost->file_index = nb_output_files - 1;
1095 1096 1097 1098
    ost->index      = idx;
    ost->st         = st;
    st->codec->codec_type = type;
    choose_encoder(o, oc, ost);
1099 1100 1101 1102 1103 1104 1105 1106

    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;

1107
    if (ost->enc) {
1108 1109 1110
        AVIOContext *s = NULL;
        char *buf = NULL, *arg = NULL, *preset = NULL;

1111
        ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122

        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");
1123
                    exit_program(1);
1124 1125
                }
                *arg++ = 0;
1126
                av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1127 1128
                av_free(buf);
            } while (!s->eof_reached);
1129
            avio_closep(&s);
1130 1131 1132 1133 1134
        }
        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);
1135
            exit_program(1);
1136
        }
1137
    } else {
1138
        ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1139 1140 1141 1142
    }

    ost->max_frames = INT64_MAX;
    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1143 1144 1145 1146 1147 1148 1149
    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;
        }
    }
1150

1151 1152 1153
    ost->copy_prior_start = -1;
    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);

1154 1155
    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
    while (bsf) {
1156
        char *arg = NULL;
1157 1158
        if (next = strchr(bsf, ','))
            *next++ = 0;
1159 1160
        if (arg = strchr(bsf, '='))
            *arg++ = 0;
1161 1162
        if (!(bsfc = av_bitstream_filter_init(bsf))) {
            av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1163
            exit_program(1);
1164 1165 1166 1167 1168
        }
        if (bsfc_prev)
            bsfc_prev->next = bsfc;
        else
            ost->bitstream_filters = bsfc;
1169
        av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179

        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);
1180
        ost->enc_ctx->codec_tag = tag;
1181 1182 1183
    }

    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1184
    if (qscale >= 0) {
1185 1186
        ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
        ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1187 1188
    }

1189 1190 1191
    MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
    ost->disposition = av_strdup(ost->disposition);

1192
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1193
        ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1194

1195
    av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1196 1197

    av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1198
    if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1199
        av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1200

1201 1202
    av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);

1203 1204 1205 1206
    ost->source_index = source_index;
    if (source_index >= 0) {
        ost->sync_ist = input_streams[source_index];
        input_streams[source_index]->discard = 0;
1207
        input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1208
    }
1209
    ost->last_mux_dts = AV_NOPTS_VALUE;
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224

    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);
1225
            exit_program(1);
1226 1227 1228 1229 1230
        }
        p++;
    }
}

1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
/* 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;

1265
    if (ost->filters_script && ost->filters) {
1266 1267
        av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
               "output stream #%d:%d.\n", nb_output_files, st->index);
1268
        exit_program(1);
1269 1270
    }

1271 1272 1273 1274
    if (ost->filters_script)
        return read_file(ost->filters_script);
    else if (ost->filters)
        return av_strdup(ost->filters);
1275 1276 1277 1278 1279

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

1280 1281 1282
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
                                     const OutputStream *ost, enum AVMediaType type)
{
1283
    if (ost->filters_script || ost->filters) {
1284
        av_log(NULL, AV_LOG_ERROR,
1285
               "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1286
               "Filtering and streamcopy cannot be used together.\n",
1287 1288 1289
               ost->filters ? "Filtergraph" : "Filtergraph script",
               ost->filters ? ost->filters : ost->filters_script,
               av_get_media_type_string(type), ost->file_index, ost->index);
1290 1291 1292 1293
        exit_program(1);
    }
}

1294
static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1295 1296 1297 1298
{
    AVStream *st;
    OutputStream *ost;
    AVCodecContext *video_enc;
1299
    char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1300

1301
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1302
    st  = ost->st;
1303
    video_enc = ost->enc_ctx;
1304

1305 1306 1307
    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);
1308
        exit_program(1);
1309
    }
1310 1311
    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");
1312

1313 1314 1315 1316 1317 1318
    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);
1319
            exit_program(1);
1320 1321 1322 1323
        }
        ost->frame_aspect_ratio = q;
    }

1324 1325 1326
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);

1327 1328
    if (!ost->stream_copy) {
        const char *p = NULL;
1329
        char *frame_size = NULL;
1330
        char *frame_pix_fmt = NULL;
1331
        char *intra_matrix = NULL, *inter_matrix = NULL;
1332
        char *chroma_intra_matrix = NULL;
1333
        int do_pass = 0;
1334 1335 1336 1337 1338
        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);
1339
            exit_program(1);
1340 1341
        }

1342
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1343
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1344 1345 1346 1347 1348
        if (frame_pix_fmt && *frame_pix_fmt == '+') {
            ost->keep_pix_fmt = 1;
            if (!*++frame_pix_fmt)
                frame_pix_fmt = NULL;
        }
1349
        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1350
            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1351
            exit_program(1);
1352 1353 1354
        }
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;

1355 1356
        if (intra_only)
            video_enc->gop_size = 0;
1357 1358 1359 1360
        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");
1361
                exit_program(1);
1362 1363 1364
            }
            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
        }
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
        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);
        }
1375 1376 1377 1378
        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");
1379
                exit_program(1);
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
            }
            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");
1390
                exit_program(1);
1391 1392
            }
            video_enc->rc_override =
1393 1394
                av_realloc_array(video_enc->rc_override,
                                 i + 1, sizeof(RcOverride));
1395 1396
            if (!video_enc->rc_override)
                exit_program(1);
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
            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;

1412 1413 1414
        if (do_psnr)
            video_enc->flags|= CODEC_FLAG_PSNR;

1415
        /* two pass mode */
1416
        MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1417
        if (do_pass) {
1418
            if (do_pass & 1) {
1419
                video_enc->flags |= CODEC_FLAG_PASS1;
1420
                av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1421 1422
            }
            if (do_pass & 2) {
1423
                video_enc->flags |= CODEC_FLAG_PASS2;
1424
                av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1425 1426 1427
            }
        }

1428 1429 1430
        MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
        if (ost->logfile_prefix &&
            !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1431
            exit_program(1);
1432

1433 1434 1435 1436 1437 1438 1439 1440 1441
        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);

1442 1443 1444

        ost->avfilter = get_ost_filters(o, oc, ost);
        if (!ost->avfilter)
1445
            exit_program(1);
1446 1447 1448 1449
    } else {
        MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
    }

1450 1451 1452
    if (ost->stream_copy)
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);

1453 1454 1455
    return ost;
}

1456
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1457
{
1458
    int n;
1459 1460 1461 1462
    AVStream *st;
    OutputStream *ost;
    AVCodecContext *audio_enc;

1463
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1464 1465
    st  = ost->st;

1466
    audio_enc = ost->enc_ctx;
1467 1468
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;

1469 1470 1471
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);

1472 1473 1474 1475 1476 1477 1478 1479 1480
    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);
1481
            exit_program(1);
1482 1483 1484 1485
        }

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

1486 1487 1488
        MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
        ost->apad = av_strdup(ost->apad);

1489 1490
        ost->avfilter = get_ost_filters(o, oc, ost);
        if (!ost->avfilter)
1491
            exit_program(1);
1492 1493 1494 1495

        /* 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];
1496
            if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1497
                (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1498 1499 1500 1501 1502 1503
                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",
1504
                           ost->file_index, ost->st->index);
1505 1506 1507 1508 1509 1510
                    continue;
                } else {
                    ist = input_streams[ost->source_index];
                }

                if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1511 1512 1513 1514 1515 1516 1517
                    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;
1518
                }
1519 1520
            }
        }
1521 1522
    }

1523 1524 1525
    if (ost->stream_copy)
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);

1526 1527 1528
    return ost;
}

1529
static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1530 1531 1532
{
    OutputStream *ost;

1533
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1534 1535
    if (!ost->stream_copy) {
        av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1536
        exit_program(1);
1537 1538 1539 1540 1541
    }

    return ost;
}

1542
static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1543
{
1544
    OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1545
    ost->stream_copy = 1;
1546
    ost->finished    = 1;
1547 1548 1549
    return ost;
}

1550
static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1551 1552 1553 1554 1555
{
    AVStream *st;
    OutputStream *ost;
    AVCodecContext *subtitle_enc;

1556
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1557
    st  = ost->st;
1558
    subtitle_enc = ost->enc_ctx;
1559 1560 1561

    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;

1562 1563
    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);

1564 1565 1566 1567 1568 1569
    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);
1570
            exit_program(1);
1571 1572 1573
        }
    }

1574 1575 1576 1577
    return ost;
}

/* arg format is "output-stream-index:streamid-value". */
1578
static int opt_streamid(void *optctx, const char *opt, const char *arg)
1579
{
1580
    OptionsContext *o = optctx;
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590
    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);
1591
        exit_program(1);
1592 1593
    }
    *p++ = '\0';
1594
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1595 1596 1597 1598 1599 1600 1601 1602 1603
    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;
1604
    AVChapter **tmp;
1605 1606
    int i;

1607
    tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1608 1609 1610 1611
    if (!tmp)
        return AVERROR(ENOMEM);
    os->chapters = tmp;

1612 1613
    for (i = 0; i < is->nb_chapters; i++) {
        AVChapter *in_ch = is->chapters[i], *out_ch;
1614 1615
        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,
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
                                       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);

1638
        os->chapters[os->nb_chapters++] = out_ch;
1639 1640 1641 1642
    }
    return 0;
}

1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656
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;
1657
        const char *enc_config;
1658 1659

        codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1660 1661 1662 1663
        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);
        }
1664 1665 1666 1667
        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);
1668 1669 1670
        ost   = new_output_stream(o, s, codec->type, -1);
        st    = ost->st;

1671 1672 1673 1674 1675 1676 1677 1678
        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);
        }
1679 1680 1681 1682

        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)
1683
            choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1684 1685 1686
        avcodec_copy_context(ost->enc_ctx, st->codec);
        if (enc_config)
            av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1687 1688 1689
    }

    avformat_close_input(&ic);
1690
    return err;
1691 1692
}

1693 1694 1695 1696 1697 1698 1699
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
                               AVFormatContext *oc)
{
    OutputStream *ost;

    switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
                                  ofilter->out_tmp->pad_idx)) {
1700 1701
    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1702 1703 1704
    default:
        av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
               "currently.\n");
1705
        exit_program(1);
1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
    }

    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);
1717
        exit_program(1);
1718 1719
    }

1720
    if (ost->avfilter && (ost->filters || ost->filters_script)) {
1721 1722 1723 1724 1725 1726 1727 1728 1729
        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);
1730 1731
    }

1732 1733
    if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
        av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1734
        exit_program(1);
1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
    }
    avfilter_inout_free(&ofilter->out_tmp);
}

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;
}

1750
static int open_output_file(OptionsContext *o, const char *filename)
1751 1752 1753 1754
{
    AVFormatContext *oc;
    int i, j, err;
    AVOutputFormat *file_oformat;
1755
    OutputFile *of;
1756 1757
    OutputStream *ost;
    InputStream  *ist;
1758 1759
    AVDictionary *unused_opts = NULL;
    AVDictionaryEntry *e = NULL;
1760 1761 1762

    if (configure_complex_filters() < 0) {
        av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1763
        exit_program(1);
1764 1765
    }

1766 1767 1768 1769 1770 1771
    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) {
1772 1773
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
        if (o->stop_time <= start_time) {
1774 1775
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
            exit_program(1);
1776
        } else {
1777
            o->recording_time = o->stop_time - start_time;
1778 1779 1780
        }
    }

1781 1782 1783
    GROW_ARRAY(output_files, nb_output_files);
    of = av_mallocz(sizeof(*of));
    if (!of)
1784
        exit_program(1);
1785 1786 1787 1788 1789 1790 1791 1792 1793
    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);

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

1797
    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1798
    if (!oc) {
1799
        print_error(filename, err);
1800
        exit_program(1);
1801
    }
1802

1803 1804 1805
    of->ctx = oc;
    if (o->recording_time != INT64_MAX)
        oc->duration = o->recording_time;
1806

1807
    file_oformat= oc->oformat;
1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828
    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;

            switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
                                          ofilter->out_tmp->pad_idx)) {
            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);
        }
    }

1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
    /* 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);
        }
    }

1839
    if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1840 1841 1842 1843 1844 1845 1846
        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);
1847
            exit_program(1);
1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
        }
        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;
1859
                    ist->st->discard = ist->user_set_discard;
1860 1861 1862 1863 1864
                    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));
1865
                exit_program(1);
1866
            }
1867
        }
1868
    } else if (!o->nb_stream_maps) {
1869
        char *subtitle_codec_name = NULL;
1870
        /* pick the "best" stream of each type */
1871 1872

        /* video: highest resolution */
1873
        if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1874
            int area = 0, idx = -1;
1875
            int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1876
            for (i = 0; i < nb_input_streams; i++) {
1877
                int new_area;
1878
                ist = input_streams[i];
1879
                new_area = ist->st->codec->width * ist->st->codec->height;
1880 1881
                if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
                    new_area = 1;
1882
                if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1883
                    new_area > area) {
1884 1885
                    if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
                        continue;
1886
                    area = new_area;
1887 1888 1889
                    idx = i;
                }
            }
1890 1891
            if (idx >= 0)
                new_video_stream(o, oc, idx);
1892 1893 1894
        }

        /* audio: most channels */
1895
        if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1896 1897 1898 1899 1900 1901 1902 1903 1904
            int channels = 0, idx = -1;
            for (i = 0; i < nb_input_streams; i++) {
                ist = input_streams[i];
                if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
                    ist->st->codec->channels > channels) {
                    channels = ist->st->codec->channels;
                    idx = i;
                }
            }
1905 1906
            if (idx >= 0)
                new_audio_stream(o, oc, idx);
1907 1908 1909
        }

        /* subtitles: pick first */
1910
        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1911
        if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1912 1913
            for (i = 0; i < nb_input_streams; i++)
                if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
                    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;
                    }
1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
                }
        }
        /* do something with data? */
    } 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 "
1963
                           "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1964
                    exit_program(1);
1965 1966 1967
                }
                init_output_filter(ofilter, o, oc);
            } else {
1968 1969
                int src_idx = input_files[map->file_index]->ist_index + map->stream_index;

1970
                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1971 1972 1973 1974 1975 1976 1977 1978 1979
                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;

1980
                switch (ist->st->codec->codec_type) {
1981 1982 1983 1984 1985
                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;
1986 1987 1988
                default:
                    av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
                           map->file_index, map->stream_index);
1989
                    exit_program(1);
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
                }
            }
        }
    }

    /* 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]);
2005
            exit_program(1);
2006 2007 2008 2009
        }
        if ((len = avio_size(pb)) <= 0) {
            av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
                   o->attachments[i]);
2010
            exit_program(1);
2011 2012 2013 2014
        }
        if (!(attachment = av_malloc(len))) {
            av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
                   o->attachments[i]);
2015
            exit_program(1);
2016 2017 2018
        }
        avio_read(pb, attachment, len);

2019
        ost = new_attachment_stream(o, oc, -1);
2020 2021
        ost->stream_copy               = 0;
        ost->attachment_filename       = o->attachments[i];
2022
        ost->finished                  = 1;
2023 2024
        ost->enc_ctx->extradata      = attachment;
        ost->enc_ctx->extradata_size = len;
2025 2026 2027

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

2031 2032 2033 2034
    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];

2035
        if ((ost->stream_copy || ost->attachment_filename)
2036 2037 2038
            && (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)
2039
                exit_program(1);
2040 2041
    }

2042 2043 2044 2045
    /* 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;
2046
        while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2047 2048 2049 2050 2051 2052 2053 2054 2055
                                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);
2056 2057 2058 2059
        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)
2060
            continue;
2061 2062


2063 2064 2065 2066 2067
        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);
2068
            exit_program(1);
2069 2070
        }

2071 2072 2073 2074
        // gop_timecode is injected by generic code but not always used
        if (!strcmp(e->key, "gop_timecode"))
            continue;

2075 2076 2077 2078 2079 2080 2081 2082 2083
        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);

2084 2085 2086 2087
    /* 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));
2088
            exit_program(1);
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
        }
    }

    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,
2099
                              &of->opts)) < 0) {
2100
            print_error(filename, err);
2101
            exit_program(1);
2102
        }
2103 2104
    } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
        assert_file_overwrite(filename);
2105 2106

    if (o->mux_preload) {
2107
        av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
    }
    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);
2118
            exit_program(1);
2119
        }
2120 2121 2122
        copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
                      in_file_index >= 0 ?
                      input_files[in_file_index]->ctx : NULL, o);
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137
    }

    /* 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);
2138
            exit_program(1);
2139 2140 2141
        }
    }
    if (o->chapters_input_file >= 0)
2142
        copy_chapters(input_files[o->chapters_input_file], of,
2143 2144 2145
                      !o->metadata_chapters_manual);

    /* copy global metadata by default */
2146
    if (!o->metadata_global_manual && nb_input_files){
2147 2148
        av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
                     AV_DICT_DONT_OVERWRITE);
2149 2150 2151 2152
        if(o->recording_time != INT64_MAX)
            av_dict_set(&oc->metadata, "duration", NULL, 0);
        av_dict_set(&oc->metadata, "creation_time", NULL, 0);
    }
2153
    if (!o->metadata_streams_manual)
2154
        for (i = of->ost_index; i < nb_output_streams; i++) {
2155 2156 2157 2158 2159
            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);
2160 2161
            if (!output_streams[i]->stream_copy)
                av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2162 2163 2164 2165 2166 2167 2168
        }

    /* process manually set metadata */
    for (i = 0; i < o->nb_metadata; i++) {
        AVDictionary **m;
        char type, *val;
        const char *stream_spec;
2169
        int index = 0, j, ret = 0;
2170 2171 2172 2173 2174

        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);
2175
            exit_program(1);
2176 2177 2178 2179 2180 2181 2182 2183 2184
        }
        *val++ = 0;

        parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
        if (type == 's') {
            for (j = 0; j < oc->nb_streams; j++) {
                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);
                } else if (ret < 0)
2185
                    exit_program(1);
2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
            }
        }
        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);
2196
                    exit_program(1);
2197 2198 2199 2200 2201
                }
                m = &oc->chapters[index]->metadata;
                break;
            default:
                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2202
                exit_program(1);
2203 2204 2205 2206 2207
            }
            av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
        }
    }

2208
    return 0;
2209 2210
}

2211
static int opt_target(void *optctx, const char *opt, const char *arg)
2212
{
2213
    OptionsContext *o = optctx;
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
    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;
2233 2234
                    if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
                        !c->time_base.num)
2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
                        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");
2257
        exit_program(1);
2258 2259 2260 2261 2262 2263 2264 2265 2266
    }

    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);
2267
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2268

2269 2270 2271 2272
        opt_default(NULL, "b:v", "1150000");
        opt_default(NULL, "maxrate", "1150000");
        opt_default(NULL, "minrate", "1150000");
        opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2273

2274
        opt_default(NULL, "b:a", "224000");
2275 2276 2277
        parse_option(o, "ar", "44100", options);
        parse_option(o, "ac", "2", options);

2278 2279
        opt_default(NULL, "packetsize", "2324");
        opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294

        /* 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);
2295
        parse_option(o, "pix_fmt", "yuv420p", options);
2296
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2297

2298 2299 2300 2301 2302
        opt_default(NULL, "b:v", "2040000");
        opt_default(NULL, "maxrate", "2516000");
        opt_default(NULL, "minrate", "0"); // 1145000;
        opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
        opt_default(NULL, "scan_offset", "1");
2303

2304
        opt_default(NULL, "b:a", "224000");
2305 2306
        parse_option(o, "ar", "44100", options);

2307
        opt_default(NULL, "packetsize", "2324");
2308 2309 2310 2311 2312 2313 2314 2315 2316

    } 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);
2317
        parse_option(o, "pix_fmt", "yuv420p", options);
2318
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2319

2320 2321 2322 2323
        opt_default(NULL, "b:v", "6000000");
        opt_default(NULL, "maxrate", "9000000");
        opt_default(NULL, "minrate", "0"); // 1500000;
        opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2324

2325 2326
        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
2327

2328
        opt_default(NULL, "b:a", "448000");
2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346
        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);
    }
2347

2348 2349
    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);
2350

2351 2352 2353
    return 0;
}

2354
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2355 2356 2357 2358 2359 2360
{
    av_free (vstats_filename);
    vstats_filename = av_strdup (arg);
    return 0;
}

2361
static int opt_vstats(void *optctx, const char *opt, const char *arg)
2362 2363 2364 2365 2366 2367 2368
{
    char filename[40];
    time_t today2 = time(NULL);
    struct tm *today = localtime(&today2);

    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
             today->tm_sec);
2369
    return opt_vstats_file(NULL, opt, filename);
2370 2371
}

2372
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2373
{
2374
    OptionsContext *o = optctx;
2375 2376 2377
    return parse_option(o, "frames:v", arg, options);
}

2378
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2379
{
2380
    OptionsContext *o = optctx;
2381 2382 2383
    return parse_option(o, "frames:a", arg, options);
}

2384
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2385
{
2386
    OptionsContext *o = optctx;
2387 2388 2389
    return parse_option(o, "frames:d", arg, options);
}

2390 2391 2392
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
{
    int ret;
2393 2394
    AVDictionary *cbak = codec_opts;
    AVDictionary *fbak = format_opts;
2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409
    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;
}

2410
static int opt_preset(void *optctx, const char *opt, const char *arg)
2411
{
2412
    OptionsContext *o = optctx;
2413 2414
    FILE *f=NULL;
    char filename[1000], line[1000], tmp_line[1000];
2415 2416 2417 2418 2419
    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);
2420 2421 2422 2423 2424 2425

    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);
2426
        exit_program(1);
2427
    }
2428 2429 2430 2431 2432 2433

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

        if (strcspn(line, "#\n\r") == 0)
            continue;
2434
        av_strlcpy(tmp_line, line, sizeof(tmp_line));
2435 2436 2437
        if (!av_strtok(key,   "=",    &value) ||
            !av_strtok(value, "\r\n", &endptr)) {
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2438
            exit_program(1);
2439 2440 2441 2442 2443 2444 2445
        }
        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);
2446
        else if (opt_default_new(o, key, value) < 0) {
2447 2448
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
                   filename, line, key, value);
2449
            exit_program(1);
2450 2451 2452 2453 2454 2455 2456 2457
        }
    }

    fclose(f);

    return 0;
}

2458
static int opt_old2new(void *optctx, const char *opt, const char *arg)
2459
{
2460
    OptionsContext *o = optctx;
2461 2462 2463 2464
    char *s = av_asprintf("%s:%c", opt + 1, *opt);
    int ret = parse_option(o, s, arg, options);
    av_free(s);
    return ret;
2465 2466
}

2467
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2468
{
2469
    OptionsContext *o = optctx;
2470 2471 2472 2473 2474

    if(!strcmp(opt, "ab")){
        av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
        return 0;
    } else if(!strcmp(opt, "b")){
2475
        av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2476 2477
        av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
        return 0;
2478
    }
2479 2480
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
    return 0;
2481 2482
}

2483
static int opt_qscale(void *optctx, const char *opt, const char *arg)
2484
{
2485
    OptionsContext *o = optctx;
2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
    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;
}

2498
static int opt_profile(void *optctx, const char *opt, const char *arg)
2499
{
2500
    OptionsContext *o = optctx;
2501 2502
    if(!strcmp(opt, "profile")){
        av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2503 2504
        av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
        return 0;
2505
    }
2506 2507
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
    return 0;
2508 2509
}

2510
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2511
{
2512
    OptionsContext *o = optctx;
2513 2514 2515
    return parse_option(o, "filter:v", arg, options);
}

2516
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2517
{
2518
    OptionsContext *o = optctx;
2519 2520 2521
    return parse_option(o, "filter:a", arg, options);
}

2522
static int opt_vsync(void *optctx, const char *opt, const char *arg)
2523 2524 2525 2526
{
    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;
2527
    else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2528 2529 2530 2531 2532 2533

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

2534
static int opt_timecode(void *optctx, const char *opt, const char *arg)
2535
{
2536
    OptionsContext *o = optctx;
2537 2538 2539
    char *tcr = av_asprintf("timecode=%s", arg);
    int ret = parse_option(o, "metadata:g", tcr, options);
    if (ret >= 0)
2540
        ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2541
    av_free(tcr);
2542 2543 2544
    return 0;
}

2545
static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2546
{
2547
    OptionsContext *o = optctx;
2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559
    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);
2560
    ret = opt_default_new(o, opt, layout_str);
2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580
    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;
}

2581
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2582
{
2583
    OptionsContext *o = optctx;
2584 2585 2586
    return parse_option(o, "q:a", arg, options);
}

2587
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2588
{
2589
    GROW_ARRAY(filtergraphs, nb_filtergraphs);
2590 2591
    if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
        return AVERROR(ENOMEM);
2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609
    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);
    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;
2610 2611 2612
    return 0;
}

2613
void show_help_default(const char *opt, const char *arg)
2614
{
2615
    /* per-file options have at least one of those set */
2616
    const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2617 2618
    int show_advanced = 0, show_avoptions = 0;

2619
    if (opt && *opt) {
2620 2621 2622 2623 2624 2625 2626
        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);
    }
2627

2628
    show_usage();
2629 2630 2631 2632 2633 2634 2635 2636

    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"
           "    See man %s for detailed description of the options.\n"
           "\n", program_name);

2637
    show_help_options(options, "Print help / information / capabilities:",
2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
                      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);
2650
    if (show_advanced)
2651 2652
        show_help_options(options, "Advanced per-file options:",
                          OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2653

2654
    show_help_options(options, "Video options:",
2655
                      OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2656 2657
    if (show_advanced)
        show_help_options(options, "Advanced Video options:",
2658
                          OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2659

2660
    show_help_options(options, "Audio options:",
2661
                      OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2662 2663
    if (show_advanced)
        show_help_options(options, "Advanced Audio options:",
2664
                          OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2665
    show_help_options(options, "Subtitle options:",
2666
                      OPT_SUBTITLE, 0, 0);
2667
    printf("\n");
2668 2669 2670 2671 2672

    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);
2673
#if CONFIG_SWSCALE
2674
        show_help_children(sws_get_class(), flags);
2675
#endif
2676
        show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2677
        show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2678
    }
2679 2680 2681 2682
}

void show_usage(void)
{
2683 2684 2685
    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");
2686 2687
}

2688 2689 2690 2691 2692 2693
enum OptGroup {
    GROUP_OUTFILE,
    GROUP_INFILE,
};

static const OptionGroupDef groups[] = {
2694 2695
    [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
    [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706
};

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;

2707
        init_options(&o);
2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718
        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);
2719
        uninit_options(&o);
2720 2721 2722 2723 2724
        if (ret < 0) {
            av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
                   inout, g->arg);
            return ret;
        }
2725
        av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2726 2727 2728 2729 2730
    }

    return 0;
}

2731
int ffmpeg_parse_options(int argc, char **argv)
2732 2733 2734 2735 2736 2737 2738 2739
{
    OptionParseContext octx;
    uint8_t error[128];
    int ret;

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

    /* split the commandline into an internal representation */
2740 2741
    ret = split_commandline(&octx, argc, argv, options, groups,
                            FF_ARRAY_ELEMS(groups));
2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775
    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;
    }

    /* 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;
    }

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;
}
2776

2777
static int opt_progress(void *optctx, const char *opt, const char *arg)
2778 2779 2780 2781 2782 2783 2784 2785
{
    AVIOContext *avio = NULL;
    int ret;

    if (!strcmp(arg, "-"))
        arg = "pipe:";
    ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
    if (ret < 0) {
2786
        av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2787 2788 2789 2790 2791 2792 2793
               arg, av_err2str(ret));
        return ret;
    }
    progress_avio = avio;
    return 0;
}

2794 2795 2796 2797
#define OFFSET(x) offsetof(OptionsContext, x)
const OptionDef options[] = {
    /* main options */
#include "cmdutils_common_opts.h"
2798 2799
    { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
                        OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2800 2801 2802
        "force format", "fmt" },
    { "y",              OPT_BOOL,                                    {              &file_overwrite },
        "overwrite output files" },
2803
    { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2804
        "never overwrite output files" },
2805 2806
    { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
                        OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2807
        "codec name", "codec" },
2808 2809
    { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
                        OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2810
        "codec name", "codec" },
2811 2812
    { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2813
        "preset name", "preset" },
2814 2815
    { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
                        OPT_OUTPUT,                                  { .func_arg = opt_map },
2816 2817
        "set input stream mapping",
        "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2818
    { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2819
        "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2820 2821
    { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2822 2823
        "set metadata information of outfile from infile",
        "outfile[,metadata]:infile[,metadata]" },
2824 2825
    { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
                        OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2826
        "set chapters mapping", "input_file_index" },
2827 2828
    { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
                        OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2829 2830
        "record or transcode \"duration\" seconds of audio/video",
        "duration" },
2831
    { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2832
        "record or transcode stop time", "time_stop" },
2833
    { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2834
        "set the limit file size in bytes", "limit_size" },
2835 2836
    { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
                        OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2837
        "set the start time offset", "time_off" },
2838 2839 2840
    { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
                        OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
        "enable/disable accurate seeking with -ss" },
2841 2842
    { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
                        OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2843
        "set the input ts offset", "time_off" },
2844 2845
    { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
                        OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2846
        "set the input ts scale", "scale" },
2847
    { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2848
        "set the recording timestamp ('now' to set the current time)", "time" },
2849
    { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2850
        "add metadata", "string=string" },
2851 2852
    { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
                        OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2853
        "set the number of data frames to output", "number" },
2854 2855
    { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
        "add timings for benchmarking" },
2856
    { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2857
      "add timings for each task" },
2858
    { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2859
      "write program-readable progress information", "url" },
2860
    { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2861
      "enable or disable interaction on standard input" },
2862
    { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2863 2864 2865 2866 2867
        "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" },
2868 2869
    { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
                        OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2870
        "read input at native frame rate", "" },
2871
    { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2872 2873 2874 2875 2876 2877 2878 2879 2880 2881
        "specify target file type (\"vcd\", \"svcd\", \"dvd\","
        " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
    { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
        "video sync method", "" },
    { "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" },
2882 2883
    { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
        "shift input timestamps to start at 0 when using copyts" },
2884 2885
    { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
        "copy input stream time base when stream copying", "mode" },
2886 2887
    { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
                        OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2888
        "finish encoding within shortest input" },
2889 2890 2891
    { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off = OFFSET(apad) },
        "audio pad", "" },
2892 2893
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
        "timestamp discontinuity delta threshold", "threshold" },
2894 2895
    { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
        "timestamp error delta threshold", "threshold" },
2896
    { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2897
        "exit on error", "error" },
2898 2899
    { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2900
        "copy initial non-keyframes" },
2901
    { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2902
        "copy or discard frames before start time" },
2903
    { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2904
        "set the number of frames to output", "number" },
2905
    { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2906
                        OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
2907
        "force codec tag/fourcc", "fourcc/tag" },
2908 2909
    { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
                        OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2910
        "use fixed quality scale (VBR)", "q" },
2911 2912
    { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
                        OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2913
        "use fixed quality scale (VBR)", "q" },
2914
    { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2915
        "set profile", "profile" },
2916
    { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2917
        "set stream filtergraph", "filter_graph" },
2918 2919
    { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
        "read stream filtergraph description from a file", "filename" },
2920
    { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2921
        "reinit filtergraph on input parameter changes", "" },
2922 2923
    { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
        "create a complex filtergraph", "graph_description" },
2924 2925
    { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
        "create a complex filtergraph", "graph_description" },
2926 2927
    { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
        "read complex filtergraph description from a file", "filename" },
2928 2929
    { "stats",          OPT_BOOL,                                    { &print_stats },
        "print progress report during encoding", },
2930 2931
    { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
                        OPT_OUTPUT,                                  { .func_arg = opt_attach },
2932
        "add an attachment to the output file", "filename" },
2933 2934
    { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
                         OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2935
        "extract an attachment into a file", "filename" },
2936 2937
    { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
        "print timestamp debugging info" },
2938 2939
    { "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." },
2940 2941 2942
    { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
                        OPT_INPUT,                                   { .off = OFFSET(discard) },
        "discard", "" },
2943 2944 2945
    { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
                        OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
        "disposition", "" },
2946 2947

    /* video options */
2948
    { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2949
        "set the number of video frames to output", "number" },
2950 2951
    { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
                      OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2952
        "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2953
    { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2954
                      OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2955
        "set frame size (WxH or abbreviation)", "size" },
2956 2957
    { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2958
        "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2959 2960
    { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                      OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2961
        "set pixel format", "format" },
2962 2963 2964 2965
    { "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" },
2966
    { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2967
        "disable video" },
2968 2969
    { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2970
        "rate control override for specific intervals", "override" },
2971 2972
    { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
                      OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2973
        "force video codec ('copy' to copy stream)", "codec" },
2974 2975 2976 2977
    { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
        "Removed" },
    { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
        "Removed" },
2978
    { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
2979
        "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2980
    { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2981
        "select the pass number (1 to 3)", "n" },
2982 2983
    { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2984
        "select two pass log file name prefix", "prefix" },
2985
    { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
2986
        "this option is deprecated, use the yadif filter instead" },
2987 2988
    { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
        "calculate PSNR of compressed frames" },
2989 2990 2991 2992
    { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
        "dump video coding statistics to file" },
    { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
        "dump video coding statistics to file", "file" },
2993
    { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2994
        "set video filters", "filter_graph" },
2995 2996
    { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2997
        "specify intra matrix coeffs", "matrix" },
2998 2999
    { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3000
        "specify inter matrix coeffs", "matrix" },
3001 3002 3003
    { "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" },
3004
    { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3005
                      OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3006
        "top=1/bottom=0/auto=-1 field first", "" },
3007
    { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3008
                      OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3009 3010 3011
        "force video tag/fourcc", "fourcc/tag" },
    { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
        "show QP histogram" },
3012 3013
    { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
                      OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3014
        "force the selected framerate, disable the best supported framerate selection" },
3015 3016
    { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
                      OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3017
        "set the value of an outfile streamid", "streamIndex:value" },
3018 3019
    { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
                          OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3020
        "force key frames at specified timestamps", "timestamps" },
3021 3022
    { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
        "audio bitrate (please use -b:a)", "bitrate" },
3023
    { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3024
        "video bitrate (please use -b:v)", "bitrate" },
3025 3026 3027 3028 3029 3030
    { "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) },
        "select a device for HW acceleration" "devicename" },
3031 3032 3033
#if HAVE_VDPAU_X11
    { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
#endif
3034 3035

    /* audio options */
3036
    { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3037
        "set the number of audio frames to output", "number" },
3038
    { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3039
        "set audio quality (codec-specific)", "quality", },
3040 3041
    { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
                        OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3042
        "set audio sampling rate (in Hz)", "rate" },
3043 3044
    { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
                        OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3045
        "set number of audio channels", "channels" },
3046
    { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3047
        "disable audio" },
3048 3049
    { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
                        OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3050
        "force audio codec ('copy' to copy stream)", "codec" },
3051
    { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3052
                        OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3053 3054 3055
        "force audio tag/fourcc", "fourcc/tag" },
    { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
        "change audio volume (256=normal)" , "volume" },
3056 3057
    { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
                        OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3058
        "set sample format", "format" },
3059 3060
    { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
                        OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3061
        "set channel layout", "layout" },
3062
    { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3063
        "set audio filters", "filter_graph" },
3064
    { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3065
      "set the maximum number of channels to try to guess the channel layout" },
3066 3067

    /* subtitle options */
3068
    { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3069
        "disable subtitle" },
3070
    { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3071
        "force subtitle codec ('copy' to copy stream)", "codec" },
3072
    { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3073
        , "force subtitle tag/fourcc", "fourcc/tag" },
3074
    { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3075
        "fix subtitles duration" },
3076
    { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3077
        "set canvas size (WxH or abbreviation)", "size" },
3078 3079

    /* grab options */
3080
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3081
        "deprecated, use -channel", "channel" },
3082
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3083
        "deprecated, use -standard", "standard" },
3084
    { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3085 3086

    /* muxer options */
3087
    { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3088
        "set the maximum demux-decode delay", "seconds" },
3089
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3090
        "set the initial demux-decode delay", "seconds" },
3091 3092
    { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
        "override the options from ffserver", "" },
3093 3094
    { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
        "specify a file in which to print sdp information", "file" },
3095

3096
    { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3097
        "A comma-separated list of bitstream filters", "bitstream_filters" },
3098
    { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3099
        "deprecated", "audio bitstream_filters" },
3100
    { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3101 3102
        "deprecated", "video bitstream_filters" },

3103
    { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3104
        "set the audio options to the indicated preset", "preset" },
3105
    { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3106
        "set the video options to the indicated preset", "preset" },
3107
    { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3108
        "set the subtitle options to the indicated preset", "preset" },
3109
    { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3110
        "set options from indicated preset file", "filename" },
3111
    /* data codec support */
3112
    { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3113
        "force data codec ('copy' to copy stream)", "codec" },
3114
    { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3115
        "disable data" },
3116 3117 3118

    { NULL, },
};