GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg_opt.c Lines: 1144 1991 57.5 %
Date: 2020-04-04 00:26:16 Branches: 896 2382 37.6 %

Line Branch Exec Source
1
2
/*
3
 * ffmpeg option parsing
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
#include <stdint.h>
23
24
#include "ffmpeg.h"
25
#include "cmdutils.h"
26
27
#include "libavformat/avformat.h"
28
29
#include "libavcodec/avcodec.h"
30
31
#include "libavfilter/avfilter.h"
32
33
#include "libavutil/avassert.h"
34
#include "libavutil/avstring.h"
35
#include "libavutil/avutil.h"
36
#include "libavutil/channel_layout.h"
37
#include "libavutil/intreadwrite.h"
38
#include "libavutil/fifo.h"
39
#include "libavutil/mathematics.h"
40
#include "libavutil/opt.h"
41
#include "libavutil/parseutils.h"
42
#include "libavutil/pixdesc.h"
43
#include "libavutil/pixfmt.h"
44
45
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46
47
#define SPECIFIER_OPT_FMT_str  "%s"
48
#define SPECIFIER_OPT_FMT_i    "%i"
49
#define SPECIFIER_OPT_FMT_i64  "%"PRId64
50
#define SPECIFIER_OPT_FMT_ui64 "%"PRIu64
51
#define SPECIFIER_OPT_FMT_f    "%f"
52
#define SPECIFIER_OPT_FMT_dbl  "%lf"
53
54
static const char *opt_name_codec_names[]               = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL};
55
static const char *opt_name_audio_channels[]            = {"ac", NULL};
56
static const char *opt_name_audio_sample_rate[]         = {"ar", NULL};
57
static const char *opt_name_frame_rates[]               = {"r", NULL};
58
static const char *opt_name_frame_sizes[]               = {"s", NULL};
59
static const char *opt_name_frame_pix_fmts[]            = {"pix_fmt", NULL};
60
static const char *opt_name_ts_scale[]                  = {"itsscale", NULL};
61
static const char *opt_name_hwaccels[]                  = {"hwaccel", NULL};
62
static const char *opt_name_hwaccel_devices[]           = {"hwaccel_device", NULL};
63
static const char *opt_name_hwaccel_output_formats[]    = {"hwaccel_output_format", NULL};
64
static const char *opt_name_autorotate[]                = {"autorotate", NULL};
65
static const char *opt_name_max_frames[]                = {"frames", "aframes", "vframes", "dframes", NULL};
66
static const char *opt_name_bitstream_filters[]         = {"bsf", "absf", "vbsf", NULL};
67
static const char *opt_name_codec_tags[]                = {"tag", "atag", "vtag", "stag", NULL};
68
static const char *opt_name_sample_fmts[]               = {"sample_fmt", NULL};
69
static const char *opt_name_qscale[]                    = {"q", "qscale", NULL};
70
static const char *opt_name_forced_key_frames[]         = {"forced_key_frames", NULL};
71
static const char *opt_name_force_fps[]                 = {"force_fps", NULL};
72
static const char *opt_name_frame_aspect_ratios[]       = {"aspect", NULL};
73
static const char *opt_name_rc_overrides[]              = {"rc_override", NULL};
74
static const char *opt_name_intra_matrices[]            = {"intra_matrix", NULL};
75
static const char *opt_name_inter_matrices[]            = {"inter_matrix", NULL};
76
static const char *opt_name_chroma_intra_matrices[]     = {"chroma_intra_matrix", NULL};
77
static const char *opt_name_top_field_first[]           = {"top", NULL};
78
static const char *opt_name_presets[]                   = {"pre", "apre", "vpre", "spre", NULL};
79
static const char *opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL};
80
static const char *opt_name_copy_prior_start[]          = {"copypriorss", NULL};
81
static const char *opt_name_filters[]                   = {"filter", "af", "vf", NULL};
82
static const char *opt_name_filter_scripts[]            = {"filter_script", NULL};
83
static const char *opt_name_reinit_filters[]            = {"reinit_filter", NULL};
84
static const char *opt_name_fix_sub_duration[]          = {"fix_sub_duration", NULL};
85
static const char *opt_name_canvas_sizes[]              = {"canvas_size", NULL};
86
static const char *opt_name_pass[]                      = {"pass", NULL};
87
static const char *opt_name_passlogfiles[]              = {"passlogfile", NULL};
88
static const char *opt_name_max_muxing_queue_size[]     = {"max_muxing_queue_size", NULL};
89
static const char *opt_name_guess_layout_max[]          = {"guess_layout_max", NULL};
90
static const char *opt_name_apad[]                      = {"apad", NULL};
91
static const char *opt_name_discard[]                   = {"discard", NULL};
92
static const char *opt_name_disposition[]               = {"disposition", NULL};
93
static const char *opt_name_time_bases[]                = {"time_base", NULL};
94
static const char *opt_name_enc_time_bases[]            = {"enc_time_base", NULL};
95
96
#define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
97
{\
98
    char namestr[128] = "";\
99
    const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
100
    for (i = 0; opt_name_##name[i]; i++)\
101
        av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
102
    av_log(NULL, AV_LOG_WARNING, "Multiple %s options specified for stream %d, only the last option '-%s%s%s "SPECIFIER_OPT_FMT_##type"' will be used.\n",\
103
           namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
104
}
105
106
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
107
{\
108
    int i, ret, matches = 0;\
109
    SpecifierOpt *so;\
110
    for (i = 0; i < o->nb_ ## name; i++) {\
111
        char *spec = o->name[i].specifier;\
112
        if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
113
            outvar = o->name[i].u.type;\
114
            so = &o->name[i];\
115
            matches++;\
116
        } else if (ret < 0)\
117
            exit_program(1);\
118
    }\
119
    if (matches > 1)\
120
       WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
121
}
122
123
#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
124
{\
125
    int i;\
126
    for (i = 0; i < o->nb_ ## name; i++) {\
127
        char *spec = o->name[i].specifier;\
128
        if (!strcmp(spec, mediatype))\
129
            outvar = o->name[i].u.type;\
130
    }\
131
}
132
133
const HWAccel hwaccels[] = {
134
#if CONFIG_VIDEOTOOLBOX
135
    { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
136
#endif
137
#if CONFIG_LIBMFX
138
    { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV },
139
#endif
140
    { 0 },
141
};
142
AVBufferRef *hw_device_ctx;
143
HWDevice *filter_hw_device;
144
145
char *vstats_filename;
146
char *sdp_filename;
147
148
float audio_drift_threshold = 0.1;
149
float dts_delta_threshold   = 10;
150
float dts_error_threshold   = 3600*30;
151
152
int audio_volume      = 256;
153
int audio_sync_method = 0;
154
int video_sync_method = VSYNC_AUTO;
155
float frame_drop_threshold = 0;
156
int do_deinterlace    = 0;
157
int do_benchmark      = 0;
158
int do_benchmark_all  = 0;
159
int do_hex_dump       = 0;
160
int do_pkt_dump       = 0;
161
int copy_ts           = 0;
162
int start_at_zero     = 0;
163
int copy_tb           = -1;
164
int debug_ts          = 0;
165
int exit_on_error     = 0;
166
int abort_on_flags    = 0;
167
int print_stats       = -1;
168
int qp_hist           = 0;
169
int stdin_interaction = 1;
170
int frame_bits_per_raw_sample = 0;
171
float max_error_rate  = 2.0/3;
172
int filter_nbthreads = 0;
173
int filter_complex_nbthreads = 0;
174
int vstats_version = 2;
175
176
177
static int intra_only         = 0;
178
static int file_overwrite     = 0;
179
static int no_file_overwrite  = 0;
180
static int do_psnr            = 0;
181
static int input_sync;
182
static int input_stream_potentially_available = 0;
183
static int ignore_unknown_streams = 0;
184
static int copy_unknown_streams = 0;
185
static int find_stream_info = 1;
186
187
11777
static void uninit_options(OptionsContext *o)
188
{
189
11777
    const OptionDef *po = options;
190
    int i;
191
192
    /* all OPT_SPEC and OPT_STRING can be freed in generic way */
193
2096306
    while (po->name) {
194
2084529
        void *dst = (uint8_t*)o + po->u.off;
195
196
2084529
        if (po->flags & OPT_SPEC) {
197
541742
            SpecifierOpt **so = dst;
198
541742
            int i, *count = (int*)(so + 1);
199
565316
            for (i = 0; i < *count; i++) {
200
23574
                av_freep(&(*so)[i].specifier);
201
23574
                if (po->flags & OPT_STRING)
202
19045
                    av_freep(&(*so)[i].u.str);
203
            }
204
541742
            av_freep(so);
205
541742
            *count = 0;
206

1542787
        } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
207
11777
            av_freep(dst);
208
2084529
        po++;
209
    }
210
211
11852
    for (i = 0; i < o->nb_stream_maps; i++)
212
75
        av_freep(&o->stream_maps[i].linklabel);
213
11777
    av_freep(&o->stream_maps);
214
11777
    av_freep(&o->audio_channel_maps);
215
11777
    av_freep(&o->streamid_map);
216
11777
    av_freep(&o->attachments);
217
11777
}
218
219
11778
static void init_options(OptionsContext *o)
220
{
221
11778
    memset(o, 0, sizeof(*o));
222
223
11778
    o->stop_time = INT64_MAX;
224
11778
    o->mux_max_delay  = 0.7;
225
11778
    o->start_time     = AV_NOPTS_VALUE;
226
11778
    o->start_time_eof = AV_NOPTS_VALUE;
227
11778
    o->recording_time = INT64_MAX;
228
11778
    o->limit_filesize = UINT64_MAX;
229
11778
    o->chapters_input_file = INT_MAX;
230
11778
    o->accurate_seek  = 1;
231
11778
}
232
233
static int show_hwaccels(void *optctx, const char *opt, const char *arg)
234
{
235
    enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
236
    int i;
237
238
    printf("Hardware acceleration methods:\n");
239
    while ((type = av_hwdevice_iterate_types(type)) !=
240
           AV_HWDEVICE_TYPE_NONE)
241
        printf("%s\n", av_hwdevice_get_type_name(type));
242
    for (i = 0; hwaccels[i].name; i++)
243
        printf("%s\n", hwaccels[i].name);
244
    printf("\n");
245
    return 0;
246
}
247
248
/* return a copy of the input with the stream specifiers removed from the keys */
249
11777
static AVDictionary *strip_specifiers(AVDictionary *dict)
250
{
251
11777
    AVDictionaryEntry *e = NULL;
252
11777
    AVDictionary    *ret = NULL;
253
254
44257
    while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
255
32480
        char *p = strchr(e->key, ':');
256
257
32480
        if (p)
258
195
            *p = 0;
259
32480
        av_dict_set(&ret, e->key, e->value, 0);
260
32480
        if (p)
261
195
            *p = ':';
262
    }
263
11777
    return ret;
264
}
265
266
static int opt_abort_on(void *optctx, const char *opt, const char *arg)
267
{
268
    static const AVOption opts[] = {
269
        { "abort_on"        , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
270
        { "empty_output"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT     },    .unit = "flags" },
271
        { NULL },
272
    };
273
    static const AVClass class = {
274
        .class_name = "",
275
        .item_name  = av_default_item_name,
276
        .option     = opts,
277
        .version    = LIBAVUTIL_VERSION_INT,
278
    };
279
    const AVClass *pclass = &class;
280
281
    return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
282
}
283
284
static int opt_sameq(void *optctx, const char *opt, const char *arg)
285
{
286
    av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
287
           "If you are looking for an option to preserve the quality (which is not "
288
           "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
289
           opt, opt);
290
    return AVERROR(EINVAL);
291
}
292
293
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
294
{
295
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
296
    return opt_default(optctx, "channel", arg);
297
}
298
299
static int opt_video_standard(void *optctx, const char *opt, const char *arg)
300
{
301
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
302
    return opt_default(optctx, "standard", arg);
303
}
304
305
14
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
306
{
307
14
    OptionsContext *o = optctx;
308
14
    return parse_option(o, "codec:a", arg, options);
309
}
310
311
4071
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
312
{
313
4071
    OptionsContext *o = optctx;
314
4071
    return parse_option(o, "codec:v", arg, options);
315
}
316
317
2
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
318
{
319
2
    OptionsContext *o = optctx;
320
2
    return parse_option(o, "codec:s", arg, options);
321
}
322
323
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
324
{
325
    OptionsContext *o = optctx;
326
    return parse_option(o, "codec:d", arg, options);
327
}
328
329
62
static int opt_map(void *optctx, const char *opt, const char *arg)
330
{
331
62
    OptionsContext *o = optctx;
332
62
    StreamMap *m = NULL;
333
62
    int i, negative = 0, file_idx, disabled = 0;
334
62
    int sync_file_idx = -1, sync_stream_idx = 0;
335
    char *p, *sync;
336
    char *map;
337
    char *allow_unused;
338
339
62
    if (*arg == '-') {
340
        negative = 1;
341
        arg++;
342
    }
343
62
    map = av_strdup(arg);
344
62
    if (!map)
345
        return AVERROR(ENOMEM);
346
347
    /* parse sync stream first, just pick first matching stream */
348
62
    if (sync = strchr(map, ',')) {
349
        *sync = 0;
350
        sync_file_idx = strtol(sync + 1, &sync, 0);
351
        if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
352
            av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
353
            exit_program(1);
354
        }
355
        if (*sync)
356
            sync++;
357
        for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
358
            if (check_stream_specifier(input_files[sync_file_idx]->ctx,
359
                                       input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
360
                sync_stream_idx = i;
361
                break;
362
            }
363
        if (i == input_files[sync_file_idx]->nb_streams) {
364
            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
365
                                       "match any streams.\n", arg);
366
            exit_program(1);
367
        }
368
        if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
369
            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
370
                                       "stream.\n", arg);
371
            exit_program(1);
372
        }
373
    }
374
375
376
62
    if (map[0] == '[') {
377
        /* this mapping refers to lavfi output */
378
3
        const char *c = map + 1;
379
3
        GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
380
3
        m = &o->stream_maps[o->nb_stream_maps - 1];
381
3
        m->linklabel = av_get_token(&c, "]");
382
3
        if (!m->linklabel) {
383
            av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
384
            exit_program(1);
385
        }
386
    } else {
387
59
        if (allow_unused = strchr(map, '?'))
388
            *allow_unused = 0;
389
59
        file_idx = strtol(map, &p, 0);
390

59
        if (file_idx >= nb_input_files || file_idx < 0) {
391
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
392
            exit_program(1);
393
        }
394
59
        if (negative)
395
            /* disable some already defined maps */
396
            for (i = 0; i < o->nb_stream_maps; i++) {
397
                m = &o->stream_maps[i];
398
                if (file_idx == m->file_index &&
399
                    check_stream_specifier(input_files[m->file_index]->ctx,
400
                                           input_files[m->file_index]->ctx->streams[m->stream_index],
401
                                           *p == ':' ? p + 1 : p) > 0)
402
                    m->disabled = 1;
403
            }
404
        else
405
166
            for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
406
107
                if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
407
107
                            *p == ':' ? p + 1 : p) <= 0)
408
35
                    continue;
409
72
                if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
410
                    disabled = 1;
411
                    continue;
412
                }
413
72
                GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
414
72
                m = &o->stream_maps[o->nb_stream_maps - 1];
415
416
72
                m->file_index   = file_idx;
417
72
                m->stream_index = i;
418
419
72
                if (sync_file_idx >= 0) {
420
                    m->sync_file_index   = sync_file_idx;
421
                    m->sync_stream_index = sync_stream_idx;
422
                } else {
423
72
                    m->sync_file_index   = file_idx;
424
72
                    m->sync_stream_index = i;
425
                }
426
            }
427
    }
428
429
62
    if (!m) {
430
        if (allow_unused) {
431
            av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
432
        } else if (disabled) {
433
            av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
434
                                       "To ignore this, add a trailing '?' to the map.\n", arg);
435
            exit_program(1);
436
        } else {
437
            av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
438
                                       "To ignore this, add a trailing '?' to the map.\n", arg);
439
            exit_program(1);
440
        }
441
    }
442
443
62
    av_freep(&map);
444
62
    return 0;
445
}
446
447
1
static int opt_attach(void *optctx, const char *opt, const char *arg)
448
{
449
1
    OptionsContext *o = optctx;
450
1
    GROW_ARRAY(o->attachments, o->nb_attachments);
451
1
    o->attachments[o->nb_attachments - 1] = arg;
452
1
    return 0;
453
}
454
455
10
static int opt_map_channel(void *optctx, const char *opt, const char *arg)
456
{
457
10
    OptionsContext *o = optctx;
458
    int n;
459
    AVStream *st;
460
    AudioChannelMap *m;
461
    char *allow_unused;
462
    char *mapchan;
463
10
    mapchan = av_strdup(arg);
464
10
    if (!mapchan)
465
        return AVERROR(ENOMEM);
466
467
10
    GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
468
10
    m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
469
470
    /* muted channel syntax */
471
10
    n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
472

10
    if ((n == 1 || n == 3) && m->channel_idx == -1) {
473
1
        m->file_idx = m->stream_idx = -1;
474
1
        if (n == 1)
475
1
            m->ofile_idx = m->ostream_idx = -1;
476
1
        av_free(mapchan);
477
1
        return 0;
478
    }
479
480
    /* normal syntax */
481
9
    n = sscanf(arg, "%d.%d.%d:%d.%d",
482
               &m->file_idx,  &m->stream_idx, &m->channel_idx,
483
               &m->ofile_idx, &m->ostream_idx);
484
485

9
    if (n != 3 && n != 5) {
486
        av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
487
               "[file.stream.channel|-1][:syncfile:syncstream]\n");
488
        exit_program(1);
489
    }
490
491
9
    if (n != 5) // only file.stream.channel specified
492
9
        m->ofile_idx = m->ostream_idx = -1;
493
494
    /* check input */
495

9
    if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
496
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
497
               m->file_idx);
498
        exit_program(1);
499
    }
500
9
    if (m->stream_idx < 0 ||
501
9
        m->stream_idx >= input_files[m->file_idx]->nb_streams) {
502
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
503
               m->file_idx, m->stream_idx);
504
        exit_program(1);
505
    }
506
9
    st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
507
9
    if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
508
        av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
509
               m->file_idx, m->stream_idx);
510
        exit_program(1);
511
    }
512
    /* allow trailing ? to map_channel */
513
9
    if (allow_unused = strchr(mapchan, '?'))
514
2
        *allow_unused = 0;
515

9
    if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
516
8
        input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
517
1
        if (allow_unused) {
518
1
            av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
519
                    m->file_idx, m->stream_idx, m->channel_idx);
520
        } else {
521
            av_log(NULL, AV_LOG_FATAL,  "mapchan: invalid audio channel #%d.%d.%d\n"
522
                    "To ignore this, add a trailing '?' to the map_channel.\n",
523
                    m->file_idx, m->stream_idx, m->channel_idx);
524
            exit_program(1);
525
        }
526
527
    }
528
9
    av_free(mapchan);
529
9
    return 0;
530
}
531
532
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
533
{
534
    av_free(sdp_filename);
535
    sdp_filename = av_strdup(arg);
536
    return 0;
537
}
538
539
#if CONFIG_VAAPI
540
static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
541
{
542
    HWDevice *dev;
543
    const char *prefix = "vaapi:";
544
    char *tmp;
545
    int err;
546
    tmp = av_asprintf("%s%s", prefix, arg);
547
    if (!tmp)
548
        return AVERROR(ENOMEM);
549
    err = hw_device_init_from_string(tmp, &dev);
550
    av_free(tmp);
551
    if (err < 0)
552
        return err;
553
    hw_device_ctx = av_buffer_ref(dev->device_ref);
554
    if (!hw_device_ctx)
555
        return AVERROR(ENOMEM);
556
    return 0;
557
}
558
#endif
559
560
static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
561
{
562
    if (!strcmp(arg, "list")) {
563
        enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
564
        printf("Supported hardware device types:\n");
565
        while ((type = av_hwdevice_iterate_types(type)) !=
566
               AV_HWDEVICE_TYPE_NONE)
567
            printf("%s\n", av_hwdevice_get_type_name(type));
568
        printf("\n");
569
        exit_program(0);
570
    } else {
571
        return hw_device_init_from_string(arg, NULL);
572
    }
573
}
574
575
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
576
{
577
    if (filter_hw_device) {
578
        av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
579
        return AVERROR(EINVAL);
580
    }
581
    filter_hw_device = hw_device_get_by_name(arg);
582
    if (!filter_hw_device) {
583
        av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
584
        return AVERROR(EINVAL);
585
    }
586
    return 0;
587
}
588
589
/**
590
 * Parse a metadata specifier passed as 'arg' parameter.
591
 * @param arg  metadata string to parse
592
 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
593
 * @param index for type c/p, chapter/program index is written here
594
 * @param stream_spec for type s, the stream specifier is written here
595
 */
596
152
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
597
{
598
152
    if (*arg) {
599
29
        *type = *arg;
600

29
        switch (*arg) {
601
17
        case 'g':
602
17
            break;
603
12
        case 's':
604

12
            if (*(++arg) && *arg != ':') {
605
                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
606
                exit_program(1);
607
            }
608
12
            *stream_spec = *arg == ':' ? arg + 1 : "";
609
12
            break;
610
        case 'c':
611
        case 'p':
612
            if (*(++arg) == ':')
613
                *index = strtol(++arg, NULL, 0);
614
            break;
615
        default:
616
            av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
617
            exit_program(1);
618
        }
619
    } else
620
123
        *type = 'g';
621
152
}
622
623
5
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
624
{
625
5
    AVDictionary **meta_in = NULL;
626
5
    AVDictionary **meta_out = NULL;
627
5
    int i, ret = 0;
628
    char type_in, type_out;
629
5
    const char *istream_spec = NULL, *ostream_spec = NULL;
630
5
    int idx_in = 0, idx_out = 0;
631
632
5
    parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
633
5
    parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
634
635
5
    if (!ic) {
636

2
        if (type_out == 'g' || !*outspec)
637
2
            o->metadata_global_manual = 1;
638

2
        if (type_out == 's' || !*outspec)
639
            o->metadata_streams_manual = 1;
640

2
        if (type_out == 'c' || !*outspec)
641
            o->metadata_chapters_manual = 1;
642
2
        return 0;
643
    }
644
645

3
    if (type_in == 'g' || type_out == 'g')
646
1
        o->metadata_global_manual = 1;
647

3
    if (type_in == 's' || type_out == 's')
648
2
        o->metadata_streams_manual = 1;
649

3
    if (type_in == 'c' || type_out == 'c')
650
        o->metadata_chapters_manual = 1;
651
652
    /* ic is NULL when just disabling automatic mappings */
653
3
    if (!ic)
654
        return 0;
655
656
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
657
    if ((index) < 0 || (index) >= (nb_elems)) {\
658
        av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
659
                (desc), (index));\
660
        exit_program(1);\
661
    }
662
663
#define SET_DICT(type, meta, context, index)\
664
        switch (type) {\
665
        case 'g':\
666
            meta = &context->metadata;\
667
            break;\
668
        case 'c':\
669
            METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
670
            meta = &context->chapters[index]->metadata;\
671
            break;\
672
        case 'p':\
673
            METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
674
            meta = &context->programs[index]->metadata;\
675
            break;\
676
        case 's':\
677
            break; /* handled separately below */ \
678
        default: av_assert0(0);\
679
        }\
680
681



3
    SET_DICT(type_in, meta_in, ic, idx_in);
682



3
    SET_DICT(type_out, meta_out, oc, idx_out);
683
684
    /* for input streams choose first matching stream */
685
3
    if (type_in == 's') {
686
3
        for (i = 0; i < ic->nb_streams; i++) {
687
3
            if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
688
2
                meta_in = &ic->streams[i]->metadata;
689
2
                break;
690
1
            } else if (ret < 0)
691
                exit_program(1);
692
        }
693
2
        if (!meta_in) {
694
            av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
695
            exit_program(1);
696
        }
697
    }
698
699
3
    if (type_out == 's') {
700
8
        for (i = 0; i < oc->nb_streams; i++) {
701
6
            if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
702
2
                meta_out = &oc->streams[i]->metadata;
703
2
                av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
704
4
            } else if (ret < 0)
705
                exit_program(1);
706
        }
707
    } else
708
1
        av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
709
710
3
    return 0;
711
}
712
713
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
714
{
715
    OptionsContext *o = optctx;
716
    char buf[128];
717
    int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
718
    struct tm time = *gmtime((time_t*)&recording_timestamp);
719
    if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
720
        return -1;
721
    parse_option(o, "metadata", buf, options);
722
723
    av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
724
                                 "tag instead.\n", opt);
725
    return 0;
726
}
727
728
10021
static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
729
{
730
    const AVCodecDescriptor *desc;
731
10021
    const char *codec_string = encoder ? "encoder" : "decoder";
732
    AVCodec *codec;
733
734
10021
    codec = encoder ?
735
10021
        avcodec_find_encoder_by_name(name) :
736
6910
        avcodec_find_decoder_by_name(name);
737
738

10021
    if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
739
1
        codec = encoder ? avcodec_find_encoder(desc->id) :
740
                          avcodec_find_decoder(desc->id);
741
1
        if (codec)
742
1
            av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
743
                   codec_string, codec->name, desc->name);
744
    }
745
746
10021
    if (!codec) {
747
        av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
748
        exit_program(1);
749
    }
750
10021
    if (codec->type != type) {
751
        av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
752
        exit_program(1);
753
    }
754
10021
    return codec;
755
}
756
757
12356
static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
758
{
759
12356
    char *codec_name = NULL;
760
761





16980
    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
762
12356
    if (codec_name) {
763
4618
        AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
764
4618
        st->codecpar->codec_id = codec->id;
765
4618
        return codec;
766
    } else
767
7738
        return avcodec_find_decoder(st->codecpar->codec_id);
768
}
769
770
/* Add all the streams from the given input file to the global
771
 * list of input streams. */
772
5904
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
773
{
774
    int i, ret;
775
776
12129
    for (i = 0; i < ic->nb_streams; i++) {
777
6225
        AVStream *st = ic->streams[i];
778
6225
        AVCodecParameters *par = st->codecpar;
779
6225
        InputStream *ist = av_mallocz(sizeof(*ist));
780
6225
        char *framerate = NULL, *hwaccel_device = NULL;
781
6225
        const char *hwaccel = NULL;
782
6225
        char *hwaccel_output_format = NULL;
783
6225
        char *codec_tag = NULL;
784
        char *next;
785
6225
        char *discard_str = NULL;
786
6225
        const AVClass *cc = avcodec_get_class();
787
6225
        const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
788
789
6225
        if (!ist)
790
            exit_program(1);
791
792
6225
        GROW_ARRAY(input_streams, nb_input_streams);
793
6225
        input_streams[nb_input_streams - 1] = ist;
794
795
6225
        ist->st = st;
796
6225
        ist->file_index = nb_input_files;
797
6225
        ist->discard = 1;
798
6225
        st->discard  = AVDISCARD_ALL;
799
6225
        ist->nb_samples = 0;
800
6225
        ist->min_pts = INT64_MAX;
801
6225
        ist->max_pts = INT64_MIN;
802
803
6225
        ist->ts_scale = 1.0;
804





6225
        MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
805
806
6225
        ist->autorotate = 1;
807





6225
        MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
808
809





6227
        MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
810
6225
        if (codec_tag) {
811
2
            uint32_t tag = strtol(codec_tag, &next, 0);
812
2
            if (*next)
813
2
                tag = AV_RL32(codec_tag);
814
2
            st->codecpar->codec_tag = tag;
815
        }
816
817
6225
        ist->dec = choose_decoder(o, ic, st);
818
6225
        ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
819
820
6225
        ist->reinit_filters = -1;
821





6225
        MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
822
823





6225
        MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
824
6225
        ist->user_set_discard = AVDISCARD_NONE;
825
826

6225
        if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
827

6225
            (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
828

6225
            (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
829

6225
            (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
830
                ist->user_set_discard = AVDISCARD_ALL;
831
832

6225
        if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
833
            av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
834
                    discard_str);
835
            exit_program(1);
836
        }
837
838
6225
        ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
839
840
6225
        ist->dec_ctx = avcodec_alloc_context3(ist->dec);
841
6225
        if (!ist->dec_ctx) {
842
            av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
843
            exit_program(1);
844
        }
845
846
6225
        ret = avcodec_parameters_to_context(ist->dec_ctx, par);
847
6225
        if (ret < 0) {
848
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
849
            exit_program(1);
850
        }
851
852
6225
        if (o->bitexact)
853
84
            ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
854
855

6225
        switch (par->codec_type) {
856
4784
        case AVMEDIA_TYPE_VIDEO:
857
4784
            if(!ist->dec)
858
21
                ist->dec = avcodec_find_decoder(par->codec_id);
859
#if FF_API_LOWRES
860
4784
            if (st->codec->lowres) {
861
1
                ist->dec_ctx->lowres = st->codec->lowres;
862
1
                ist->dec_ctx->width  = st->codec->width;
863
1
                ist->dec_ctx->height = st->codec->height;
864
1
                ist->dec_ctx->coded_width  = st->codec->coded_width;
865
1
                ist->dec_ctx->coded_height = st->codec->coded_height;
866
            }
867
#endif
868
869
            // avformat_find_stream_info() doesn't set this for us anymore.
870
4784
            ist->dec_ctx->framerate = st->avg_frame_rate;
871
872





4808
            MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
873

4784
            if (framerate && av_parse_video_rate(&ist->framerate,
874
                                                 framerate) < 0) {
875
                av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
876
                       framerate);
877
                exit_program(1);
878
            }
879
880
4784
            ist->top_field_first = -1;
881





4784
            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
882
883





9327
            MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
884





4784
            MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
885
                                 hwaccel_output_format, ic, st);
886
887

4784
            if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
888
                av_log(NULL, AV_LOG_WARNING,
889
                    "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
890
                    "with old commandlines. This behaviour is DEPRECATED and will be removed "
891
                    "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
892
                ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
893
4784
            } else if (hwaccel_output_format) {
894
                ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
895
                if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
896
                    av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
897
                           "format: %s", hwaccel_output_format);
898
                }
899
            } else {
900
4784
                ist->hwaccel_output_format = AV_PIX_FMT_NONE;
901
            }
902
903
4784
            if (hwaccel) {
904
                // The NVDEC hwaccels use a CUDA device, so remap the name here.
905

4543
                if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
906
                    hwaccel = "cuda";
907
908
4543
                if (!strcmp(hwaccel, "none"))
909
4543
                    ist->hwaccel_id = HWACCEL_NONE;
910
                else if (!strcmp(hwaccel, "auto"))
911
                    ist->hwaccel_id = HWACCEL_AUTO;
912
                else {
913
                    enum AVHWDeviceType type;
914
                    int i;
915
                    for (i = 0; hwaccels[i].name; i++) {
916
                        if (!strcmp(hwaccels[i].name, hwaccel)) {
917
                            ist->hwaccel_id = hwaccels[i].id;
918
                            break;
919
                        }
920
                    }
921
922
                    if (!ist->hwaccel_id) {
923
                        type = av_hwdevice_find_type_by_name(hwaccel);
924
                        if (type != AV_HWDEVICE_TYPE_NONE) {
925
                            ist->hwaccel_id = HWACCEL_GENERIC;
926
                            ist->hwaccel_device_type = type;
927
                        }
928
                    }
929
930
                    if (!ist->hwaccel_id) {
931
                        av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
932
                               hwaccel);
933
                        av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
934
                        type = AV_HWDEVICE_TYPE_NONE;
935
                        while ((type = av_hwdevice_iterate_types(type)) !=
936
                               AV_HWDEVICE_TYPE_NONE)
937
                            av_log(NULL, AV_LOG_FATAL, "%s ",
938
                                   av_hwdevice_get_type_name(type));
939
                        for (i = 0; hwaccels[i].name; i++)
940
                            av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
941
                        av_log(NULL, AV_LOG_FATAL, "\n");
942
                        exit_program(1);
943
                    }
944
                }
945
            }
946
947





4784
            MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
948
4784
            if (hwaccel_device) {
949
                ist->hwaccel_device = av_strdup(hwaccel_device);
950
                if (!ist->hwaccel_device)
951
                    exit_program(1);
952
            }
953
954
4784
            ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
955
956
4784
            break;
957
1347
        case AVMEDIA_TYPE_AUDIO:
958
1347
            ist->guess_layout_max = INT_MAX;
959





1351
            MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
960
1347
            guess_input_channel_layout(ist);
961
1347
            break;
962
93
        case AVMEDIA_TYPE_DATA:
963
        case AVMEDIA_TYPE_SUBTITLE: {
964
93
            char *canvas_size = NULL;
965
93
            if(!ist->dec)
966
48
                ist->dec = avcodec_find_decoder(par->codec_id);
967





93
            MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
968





93
            MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
969

93
            if (canvas_size &&
970
                av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
971
                av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
972
                exit_program(1);
973
            }
974
93
            break;
975
        }
976
1
        case AVMEDIA_TYPE_ATTACHMENT:
977
        case AVMEDIA_TYPE_UNKNOWN:
978
1
            break;
979
        default:
980
            abort();
981
        }
982
983
6225
        ret = avcodec_parameters_from_context(par, ist->dec_ctx);
984
6225
        if (ret < 0) {
985
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
986
            exit_program(1);
987
        }
988
    }
989
5904
}
990
991
5820
static void assert_file_overwrite(const char *filename)
992
{
993
5820
    const char *proto_name = avio_find_protocol_name(filename);
994
995

5820
    if (file_overwrite && no_file_overwrite) {
996
        fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
997
        exit_program(1);
998
    }
999
1000
5820
    if (!file_overwrite) {
1001

4360
        if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
1002
            if (stdin_interaction && !no_file_overwrite) {
1003
                fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
1004
                fflush(stderr);
1005
                term_exit();
1006
                signal(SIGINT, SIG_DFL);
1007
                if (!read_yesno()) {
1008
                    av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
1009
                    exit_program(1);
1010
                }
1011
                term_init();
1012
            }
1013
            else {
1014
                av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1015
                exit_program(1);
1016
            }
1017
        }
1018
    }
1019
1020

5820
    if (proto_name && !strcmp(proto_name, "file")) {
1021
3219
        for (int i = 0; i < nb_input_files; i++) {
1022
1630
             InputFile *file = input_files[i];
1023
1630
             if (file->ctx->iformat->flags & AVFMT_NOFILE)
1024
108
                 continue;
1025
1522
             if (!strcmp(filename, file->ctx->url)) {
1026
                 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1027
                 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1028
                 exit_program(1);
1029
             }
1030
        }
1031
    }
1032
5820
}
1033
1034
static void dump_attachment(AVStream *st, const char *filename)
1035
{
1036
    int ret;
1037
    AVIOContext *out = NULL;
1038
    AVDictionaryEntry *e;
1039
1040
    if (!st->codecpar->extradata_size) {
1041
        av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1042
               nb_input_files - 1, st->index);
1043
        return;
1044
    }
1045
    if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1046
        filename = e->value;
1047
    if (!*filename) {
1048
        av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1049
               "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1050
        exit_program(1);
1051
    }
1052
1053
    assert_file_overwrite(filename);
1054
1055
    if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1056
        av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1057
               filename);
1058
        exit_program(1);
1059
    }
1060
1061
    avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
1062
    avio_flush(out);
1063
    avio_close(out);
1064
}
1065
1066
5905
static int open_input_file(OptionsContext *o, const char *filename)
1067
{
1068
    InputFile *f;
1069
    AVFormatContext *ic;
1070
5905
    AVInputFormat *file_iformat = NULL;
1071
    int err, i, ret;
1072
    int64_t timestamp;
1073
5905
    AVDictionary *unused_opts = NULL;
1074
5905
    AVDictionaryEntry *e = NULL;
1075
5905
    char *   video_codec_name = NULL;
1076
5905
    char *   audio_codec_name = NULL;
1077
5905
    char *subtitle_codec_name = NULL;
1078
5905
    char *    data_codec_name = NULL;
1079
5905
    int scan_all_pmts_set = 0;
1080
1081

5905
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1082
        o->stop_time = INT64_MAX;
1083
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1084
    }
1085
1086

5905
    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1087
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1088
        if (o->stop_time <= start_time) {
1089
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1090
            exit_program(1);
1091
        } else {
1092
            o->recording_time = o->stop_time - start_time;
1093
        }
1094
    }
1095
1096
5905
    if (o->format) {
1097
2814
        if (!(file_iformat = av_find_input_format(o->format))) {
1098
            av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1099
            exit_program(1);
1100
        }
1101
    }
1102
1103
5905
    if (!strcmp(filename, "-"))
1104
        filename = "pipe:";
1105
1106
11810
    stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1107
5905
                         strcmp(filename, "/dev/stdin");
1108
1109
    /* get default parameters from command line */
1110
5905
    ic = avformat_alloc_context();
1111
5905
    if (!ic) {
1112
        print_error(filename, AVERROR(ENOMEM));
1113
        exit_program(1);
1114
    }
1115
5905
    if (o->nb_audio_sample_rate) {
1116
63
        av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1117
    }
1118
5905
    if (o->nb_audio_channels) {
1119
        /* because we set audio_channels based on both the "ac" and
1120
         * "channel_layout" options, we need to check that the specified
1121
         * demuxer actually has the "channels" option before setting it */
1122

18
        if (file_iformat && file_iformat->priv_class &&
1123
9
            av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1124
                        AV_OPT_SEARCH_FAKE_OBJ)) {
1125
9
            av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1126
        }
1127
    }
1128
5905
    if (o->nb_frame_rates) {
1129
        /* set the format-level framerate option;
1130
         * this is important for video grabbers, e.g. x11 */
1131

48
        if (file_iformat && file_iformat->priv_class &&
1132
24
            av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1133
                        AV_OPT_SEARCH_FAKE_OBJ)) {
1134
24
            av_dict_set(&o->g->format_opts, "framerate",
1135
24
                        o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1136
        }
1137
    }
1138
5905
    if (o->nb_frame_sizes) {
1139
492
        av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1140
    }
1141
5905
    if (o->nb_frame_pix_fmts)
1142
497
        av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1143
1144

8214
    MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
1145

8214
    MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
1146

8214
    MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1147

8214
    MATCH_PER_TYPE_OPT(codec_names, str,     data_codec_name, ic, "d");
1148
1149
5905
    if (video_codec_name)
1150
2276
        ic->video_codec    = find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
1151
5905
    if (audio_codec_name)
1152
16
        ic->audio_codec    = find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
1153
5905
    if (subtitle_codec_name)
1154
        ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1155
5905
    if (data_codec_name)
1156
        ic->data_codec     = find_codec_or_die(data_codec_name    , AVMEDIA_TYPE_DATA    , 0);
1157
1158
5905
    ic->video_codec_id     = video_codec_name    ? ic->video_codec->id    : AV_CODEC_ID_NONE;
1159
5905
    ic->audio_codec_id     = audio_codec_name    ? ic->audio_codec->id    : AV_CODEC_ID_NONE;
1160
5905
    ic->subtitle_codec_id  = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1161
5905
    ic->data_codec_id      = data_codec_name     ? ic->data_codec->id     : AV_CODEC_ID_NONE;
1162
1163
5905
    ic->flags |= AVFMT_FLAG_NONBLOCK;
1164
5905
    if (o->bitexact)
1165
75
        ic->flags |= AVFMT_FLAG_BITEXACT;
1166
5905
    ic->interrupt_callback = int_cb;
1167
1168
5905
    if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1169
5905
        av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1170
5905
        scan_all_pmts_set = 1;
1171
    }
1172
    /* open the input file with generic avformat function */
1173
5905
    err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1174
5905
    if (err < 0) {
1175
1
        print_error(filename, err);
1176
1
        if (err == AVERROR_PROTOCOL_NOT_FOUND)
1177
            av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1178
1
        exit_program(1);
1179
    }
1180
5904
    if (scan_all_pmts_set)
1181
5904
        av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1182
5904
    remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1183
5904
    assert_avoptions(o->g->format_opts);
1184
1185
    /* apply forced codec ids */
1186
12035
    for (i = 0; i < ic->nb_streams; i++)
1187
6131
        choose_decoder(o, ic, ic->streams[i]);
1188
1189
5904
    if (find_stream_info) {
1190
5904
        AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1191
5904
        int orig_nb_streams = ic->nb_streams;
1192
1193
        /* If not enough info to get the stream parameters, we decode the
1194
           first frames to get it. (used in mpeg case for example) */
1195
5904
        ret = avformat_find_stream_info(ic, opts);
1196
1197
12035
        for (i = 0; i < orig_nb_streams; i++)
1198
6131
            av_dict_free(&opts[i]);
1199
5904
        av_freep(&opts);
1200
1201
5904
        if (ret < 0) {
1202
            av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1203
            if (ic->nb_streams == 0) {
1204
                avformat_close_input(&ic);
1205
                exit_program(1);
1206
            }
1207
        }
1208
    }
1209
1210

5904
    if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1211
        av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1212
        o->start_time_eof = AV_NOPTS_VALUE;
1213
    }
1214
1215
5904
    if (o->start_time_eof != AV_NOPTS_VALUE) {
1216
        if (o->start_time_eof >= 0) {
1217
            av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1218
            exit_program(1);
1219
        }
1220
        if (ic->duration > 0) {
1221
            o->start_time = o->start_time_eof + ic->duration;
1222
            if (o->start_time < 0) {
1223
                av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1224
                o->start_time = AV_NOPTS_VALUE;
1225
            }
1226
        } else
1227
            av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1228
    }
1229
5904
    timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1230
    /* add the stream start time */
1231

5904
    if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1232
4443
        timestamp += ic->start_time;
1233
1234
    /* if seeking requested, we execute it */
1235
5904
    if (o->start_time != AV_NOPTS_VALUE) {
1236
21
        int64_t seek_timestamp = timestamp;
1237
1238
21
        if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1239
21
            int dts_heuristic = 0;
1240
42
            for (i=0; i<ic->nb_streams; i++) {
1241
21
                const AVCodecParameters *par = ic->streams[i]->codecpar;
1242
21
                if (par->video_delay) {
1243
                    dts_heuristic = 1;
1244
                    break;
1245
                }
1246
            }
1247
21
            if (dts_heuristic) {
1248
                seek_timestamp -= 3*AV_TIME_BASE / 23;
1249
            }
1250
        }
1251
21
        ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1252
21
        if (ret < 0) {
1253
1
            av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1254
1
                   filename, (double)timestamp / AV_TIME_BASE);
1255
        }
1256
    }
1257
1258
    /* update the current parameters so that they match the one of the input stream */
1259
5904
    add_input_streams(o, ic);
1260
1261
    /* dump the file content */
1262
5904
    av_dump_format(ic, nb_input_files, filename, 0);
1263
1264
5904
    GROW_ARRAY(input_files, nb_input_files);
1265
5904
    f = av_mallocz(sizeof(*f));
1266
5904
    if (!f)
1267
        exit_program(1);
1268
5904
    input_files[nb_input_files - 1] = f;
1269
1270
5904
    f->ctx        = ic;
1271
5904
    f->ist_index  = nb_input_streams - ic->nb_streams;
1272
5904
    f->start_time = o->start_time;
1273
5904
    f->recording_time = o->recording_time;
1274
5904
    f->input_ts_offset = o->input_ts_offset;
1275

5904
    f->ts_offset  = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1276
5904
    f->nb_streams = ic->nb_streams;
1277
5904
    f->rate_emu   = o->rate_emu;
1278
5904
    f->accurate_seek = o->accurate_seek;
1279
5904
    f->loop = o->loop;
1280
5904
    f->duration = 0;
1281
5904
    f->time_base = (AVRational){ 1, 1 };
1282
#if HAVE_THREADS
1283
5904
    f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1284
#endif
1285
1286
    /* check if all codec options have been used */
1287
5904
    unused_opts = strip_specifiers(o->g->codec_opts);
1288
12129
    for (i = f->ist_index; i < nb_input_streams; i++) {
1289
6225
        e = NULL;
1290
25281
        while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1291
                                AV_DICT_IGNORE_SUFFIX)))
1292
19056
            av_dict_set(&unused_opts, e->key, NULL, 0);
1293
    }
1294
1295
5904
    e = NULL;
1296
6162
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1297
258
        const AVClass *class = avcodec_get_class();
1298
258
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1299
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1300
258
        const AVClass *fclass = avformat_get_class();
1301
258
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1302
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1303

258
        if (!option || foption)
1304
            continue;
1305
1306
1307
258
        if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1308
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1309
                   "input file #%d (%s) is not a decoding option.\n", e->key,
1310
                   option->help ? option->help : "", nb_input_files - 1,
1311
                   filename);
1312
            exit_program(1);
1313
        }
1314
1315
258
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1316
               "input file #%d (%s) has not been used for any stream. The most "
1317
               "likely reason is either wrong type (e.g. a video option with "
1318
               "no video streams) or that it is a private option of some decoder "
1319
               "which was not actually used for any stream.\n", e->key,
1320
258
               option->help ? option->help : "", nb_input_files - 1, filename);
1321
    }
1322
5904
    av_dict_free(&unused_opts);
1323
1324
5904
    for (i = 0; i < o->nb_dump_attachment; i++) {
1325
        int j;
1326
1327
        for (j = 0; j < ic->nb_streams; j++) {
1328
            AVStream *st = ic->streams[j];
1329
1330
            if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1331
                dump_attachment(st, o->dump_attachment[i].u.str);
1332
        }
1333
    }
1334
1335
5904
    input_stream_potentially_available = 1;
1336
1337
5904
    return 0;
1338
}
1339
1340
static uint8_t *get_line(AVIOContext *s)
1341
{
1342
    AVIOContext *line;
1343
    uint8_t *buf;
1344
    char c;
1345
1346
    if (avio_open_dyn_buf(&line) < 0) {
1347
        av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1348
        exit_program(1);
1349
    }
1350
1351
    while ((c = avio_r8(s)) && c != '\n')
1352
        avio_w8(line, c);
1353
    avio_w8(line, 0);
1354
    avio_close_dyn_buf(line, &buf);
1355
1356
    return buf;
1357
}
1358
1359
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1360
{
1361
    int i, ret = -1;
1362
    char filename[1000];
1363
    const char *base[3] = { getenv("AVCONV_DATADIR"),
1364
                            getenv("HOME"),
1365
                            AVCONV_DATADIR,
1366
                            };
1367
1368
    for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1369
        if (!base[i])
1370
            continue;
1371
        if (codec_name) {
1372
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1373
                     i != 1 ? "" : "/.avconv", codec_name, preset_name);
1374
            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1375
        }
1376
        if (ret < 0) {
1377
            snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1378
                     i != 1 ? "" : "/.avconv", preset_name);
1379
            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1380
        }
1381
    }
1382
    return ret;
1383
}
1384
1385
6020
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1386
{
1387
6020
    enum AVMediaType type = ost->st->codecpar->codec_type;
1388
6020
    char *codec_name = NULL;
1389
1390

6020
    if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1391





9898
        MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1392
6009
        if (!codec_name) {
1393
5230
            ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1394
2615
                                                         NULL, ost->st->codecpar->codec_type);
1395
2615
            ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1396
2615
            if (!ost->enc) {
1397
                av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1398
                       "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1399
                       "probably disabled. Please choose an encoder manually.\n",
1400
                       ost->file_index, ost->index, s->oformat->name,
1401
                       avcodec_get_name(ost->st->codecpar->codec_id));
1402
                return AVERROR_ENCODER_NOT_FOUND;
1403
            }
1404
3394
        } else if (!strcmp(codec_name, "copy"))
1405
283
            ost->stream_copy = 1;
1406
        else {
1407
3111
            ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1408
3111
            ost->st->codecpar->codec_id = ost->enc->id;
1409
        }
1410
6009
        ost->encoding_needed = !ost->stream_copy;
1411
    } else {
1412
        /* no encoding supported for other media types */
1413
11
        ost->stream_copy     = 1;
1414
11
        ost->encoding_needed = 0;
1415
    }
1416
1417
6020
    return 0;
1418
}
1419
1420
6020
static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1421
{
1422
    OutputStream *ost;
1423
6020
    AVStream *st = avformat_new_stream(oc, NULL);
1424
6020
    int idx      = oc->nb_streams - 1, ret = 0;
1425
6020
    const char *bsfs = NULL, *time_base = NULL;
1426
6020
    char *next, *codec_tag = NULL;
1427
6020
    double qscale = -1;
1428
    int i;
1429
1430
6020
    if (!st) {
1431
        av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1432
        exit_program(1);
1433
    }
1434
1435
6020
    if (oc->nb_streams - 1 < o->nb_streamid_map)
1436
        st->id = o->streamid_map[oc->nb_streams - 1];
1437
1438
6020
    GROW_ARRAY(output_streams, nb_output_streams);
1439
6020
    if (!(ost = av_mallocz(sizeof(*ost))))
1440
        exit_program(1);
1441
6020
    output_streams[nb_output_streams - 1] = ost;
1442
1443
6020
    ost->file_index = nb_output_files - 1;
1444
6020
    ost->index      = idx;
1445
6020
    ost->st         = st;
1446
6020
    ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1447
6020
    st->codecpar->codec_type = type;
1448
1449
6020
    ret = choose_encoder(o, oc, ost);
1450
6020
    if (ret < 0) {
1451
        av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1452
               "%d:%d\n", ost->file_index, ost->index);
1453
        exit_program(1);
1454
    }
1455
1456
6020
    ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1457
6020
    if (!ost->enc_ctx) {
1458
        av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1459
        exit_program(1);
1460
    }
1461
6020
    ost->enc_ctx->codec_type = type;
1462
1463
6020
    ost->ref_par = avcodec_parameters_alloc();
1464
6020
    if (!ost->ref_par) {
1465
        av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1466
        exit_program(1);
1467
    }
1468
1469
6020
    if (ost->enc) {
1470
5726
        AVIOContext *s = NULL;
1471
5726
        char *buf = NULL, *arg = NULL, *preset = NULL;
1472
1473
5726
        ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1474
1475





5726
        MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1476

5726
        if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1477
            do  {
1478
                buf = get_line(s);
1479
                if (!buf[0] || buf[0] == '#') {
1480
                    av_free(buf);
1481
                    continue;
1482
                }
1483
                if (!(arg = strchr(buf, '='))) {
1484
                    av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1485
                    exit_program(1);
1486
                }
1487
                *arg++ = 0;
1488
                av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1489
                av_free(buf);
1490
            } while (!s->eof_reached);
1491
            avio_closep(&s);
1492
        }
1493
5726
        if (ret) {
1494
            av_log(NULL, AV_LOG_FATAL,
1495
                   "Preset %s specified for stream %d:%d, but could not be opened.\n",
1496
                   preset, ost->file_index, ost->index);
1497
            exit_program(1);
1498
        }
1499
    } else {
1500
294
        ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1501
    }
1502
1503
1504
6020
    if (o->bitexact)
1505
1665
        ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1506
1507





6021
    MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1508
6020
    if (time_base) {
1509
        AVRational q;
1510
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1511

1
            q.num <= 0 || q.den <= 0) {
1512
            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1513
            exit_program(1);
1514
        }
1515
1
        st->time_base = q;
1516
    }
1517
1518





6020
    MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1519
6020
    if (time_base) {
1520
        AVRational q;
1521
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1522
1
            q.den <= 0) {
1523
            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1524
            exit_program(1);
1525
        }
1526
1
        ost->enc_timebase = q;
1527
    }
1528
1529
6020
    ost->max_frames = INT64_MAX;
1530





17584
    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1531
10170
    for (i = 0; i<o->nb_max_frames; i++) {
1532
4156
        char *p = o->max_frames[i].specifier;
1533

4156
        if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1534
6
            av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1535
6
            break;
1536
        }
1537
    }
1538
1539
6020
    ost->copy_prior_start = -1;
1540





6020
    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1541
1542





6104
    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1543

6104
    while (bsfs && *bsfs) {
1544
        const AVBitStreamFilter *filter;
1545
        char *bsf, *bsf_options_str, *bsf_name;
1546
1547
84
        bsf = av_get_token(&bsfs, ",");
1548
84
        if (!bsf)
1549
            exit_program(1);
1550
84
        bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1551
84
        if (!bsf_name)
1552
            exit_program(1);
1553
1554
84
        filter = av_bsf_get_by_name(bsf_name);
1555
84
        if (!filter) {
1556
            av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1557
            exit_program(1);
1558
        }
1559
1560
168
        ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1561
84
                                        ost->nb_bitstream_filters + 1,
1562
                                        sizeof(*ost->bsf_ctx));
1563
84
        if (!ost->bsf_ctx)
1564
            exit_program(1);
1565
1566
84
        ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1567
84
        if (ret < 0) {
1568
            av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1569
            exit_program(1);
1570
        }
1571
1572
84
        ost->nb_bitstream_filters++;
1573
1574

84
        if (bsf_options_str && filter->priv_class) {
1575
10
            const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1576
10
            const char * shorthand[2] = {NULL};
1577
1578
10
            if (opt)
1579
10
                shorthand[0] = opt->name;
1580
1581
10
            ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1582
10
            if (ret < 0) {
1583
                av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1584
                exit_program(1);
1585
            }
1586
        }
1587
84
        av_freep(&bsf);
1588
1589
84
        if (*bsfs)
1590
            bsfs++;
1591
    }
1592
1593





6026
    MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1594
6020
    if (codec_tag) {
1595
6
        uint32_t tag = strtol(codec_tag, &next, 0);
1596
6
        if (*next)
1597
6
            tag = AV_RL32(codec_tag);
1598
6
        ost->st->codecpar->codec_tag =
1599
6
        ost->enc_ctx->codec_tag = tag;
1600
    }
1601
1602





6306
    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1603
6020
    if (qscale >= 0) {
1604
232
        ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1605
232
        ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1606
    }
1607
1608





6020
    MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1609
6020
    ost->disposition = av_strdup(ost->disposition);
1610
1611
6020
    ost->max_muxing_queue_size = 128;
1612





6022
    MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1613
6020
    ost->max_muxing_queue_size *= sizeof(AVPacket);
1614
1615
6020
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1616
2285
        ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1617
1618
6020
    av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1619
1620
6020
    av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1621

6020
    if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1622
52
        av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1623
1624
6020
    av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1625
1626
6020
    ost->source_index = source_index;
1627
6020
    if (source_index >= 0) {
1628
5942
        ost->sync_ist = input_streams[source_index];
1629
5942
        input_streams[source_index]->discard = 0;
1630
5942
        input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1631
    }
1632
6020
    ost->last_mux_dts = AV_NOPTS_VALUE;
1633
1634
6020
    ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1635
6020
    if (!ost->muxing_queue)
1636
        exit_program(1);
1637
1638
6020
    return ost;
1639
}
1640
1641
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1642
{
1643
    int i;
1644
    const char *p = str;
1645
    for (i = 0;; i++) {
1646
        dest[i] = atoi(p);
1647
        if (i == 63)
1648
            break;
1649
        p = strchr(p, ',');
1650
        if (!p) {
1651
            av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1652
            exit_program(1);
1653
        }
1654
        p++;
1655
    }
1656
}
1657
1658
/* read file contents into a string */
1659
26
static uint8_t *read_file(const char *filename)
1660
{
1661
26
    AVIOContext *pb      = NULL;
1662
26
    AVIOContext *dyn_buf = NULL;
1663
26
    int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1664
    uint8_t buf[1024], *str;
1665
1666
26
    if (ret < 0) {
1667
        av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1668
        return NULL;
1669
    }
1670
1671
26
    ret = avio_open_dyn_buf(&dyn_buf);
1672
26
    if (ret < 0) {
1673
        avio_closep(&pb);
1674
        return NULL;
1675
    }
1676
52
    while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1677
26
        avio_write(dyn_buf, buf, ret);
1678
26
    avio_w8(dyn_buf, 0);
1679
26
    avio_closep(&pb);
1680
1681
26
    ret = avio_close_dyn_buf(dyn_buf, &str);
1682
26
    if (ret < 0)
1683
        return NULL;
1684
26
    return str;
1685
}
1686
1687
5696
static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1688
                             OutputStream *ost)
1689
{
1690
5696
    AVStream *st = ost->st;
1691
1692

5696
    if (ost->filters_script && ost->filters) {
1693
        av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1694
               "output stream #%d:%d.\n", nb_output_files, st->index);
1695
        exit_program(1);
1696
    }
1697
1698
5696
    if (ost->filters_script)
1699
4
        return read_file(ost->filters_script);
1700
5692
    else if (ost->filters)
1701
2554
        return av_strdup(ost->filters);
1702
1703
3138
    return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1704
                     "null" : "anull");
1705
}
1706
1707
276
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1708
                                     const OutputStream *ost, enum AVMediaType type)
1709
{
1710

276
    if (ost->filters_script || ost->filters) {
1711
        av_log(NULL, AV_LOG_ERROR,
1712
               "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1713
               "Filtering and streamcopy cannot be used together.\n",
1714
               ost->filters ? "Filtergraph" : "Filtergraph script",
1715
               ost->filters ? ost->filters : ost->filters_script,
1716
               av_get_media_type_string(type), ost->file_index, ost->index);
1717
        exit_program(1);
1718
    }
1719
276
}
1720
1721
4764
static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1722
{
1723
    AVStream *st;
1724
    OutputStream *ost;
1725
    AVCodecContext *video_enc;
1726
4764
    char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1727
1728
4764
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1729
4764
    st  = ost->st;
1730
4764
    video_enc = ost->enc_ctx;
1731
1732





4785
    MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1733

4764
    if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1734
        av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1735
        exit_program(1);
1736
    }
1737

4764
    if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1738
        av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1739
1740





4764
    MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1741
4764
    if (frame_aspect_ratio) {
1742
        AVRational q;
1743
        if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1744
            q.num <= 0 || q.den <= 0) {
1745
            av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1746
            exit_program(1);
1747
        }
1748
        ost->frame_aspect_ratio = q;
1749
    }
1750
1751





4767
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1752





6928
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1753
1754
4764
    if (!ost->stream_copy) {
1755
4593
        const char *p = NULL;
1756
4593
        char *frame_size = NULL;
1757
4593
        char *frame_pix_fmt = NULL;
1758
4593
        char *intra_matrix = NULL, *inter_matrix = NULL;
1759
4593
        char *chroma_intra_matrix = NULL;
1760
4593
        int do_pass = 0;
1761
        int i;
1762
1763





5208
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1764

4593
        if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1765
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1766
            exit_program(1);
1767
        }
1768
1769
4593
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1770





7889
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1771

4593
        if (frame_pix_fmt && *frame_pix_fmt == '+') {
1772
            ost->keep_pix_fmt = 1;
1773
            if (!*++frame_pix_fmt)
1774
                frame_pix_fmt = NULL;
1775
        }
1776

4593
        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1777
            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1778
            exit_program(1);
1779
        }
1780
4593
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1781
1782
4593
        if (intra_only)
1783
            video_enc->gop_size = 0;
1784





4593
        MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1785
4593
        if (intra_matrix) {
1786
            if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1787
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1788
                exit_program(1);
1789
            }
1790
            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1791
        }
1792





4593
        MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1793
4593
        if (chroma_intra_matrix) {
1794
            uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1795
            if (!p) {
1796
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1797
                exit_program(1);
1798
            }
1799
            video_enc->chroma_intra_matrix = p;
1800
            parse_matrix_coeffs(p, chroma_intra_matrix);
1801
        }
1802





4593
        MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1803
4593
        if (inter_matrix) {
1804
            if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1805
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1806
                exit_program(1);
1807
            }
1808
            parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1809
        }
1810
1811





4593
        MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1812
4593
        for (i = 0; p; i++) {
1813
            int start, end, q;
1814
            int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1815
            if (e != 3) {
1816
                av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1817
                exit_program(1);
1818
            }
1819
            video_enc->rc_override =
1820
                av_realloc_array(video_enc->rc_override,
1821
                                 i + 1, sizeof(RcOverride));
1822
            if (!video_enc->rc_override) {
1823
                av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1824
                exit_program(1);
1825
            }
1826
            video_enc->rc_override[i].start_frame = start;
1827
            video_enc->rc_override[i].end_frame   = end;
1828
            if (q > 0) {
1829
                video_enc->rc_override[i].qscale         = q;
1830
                video_enc->rc_override[i].quality_factor = 1.0;
1831
            }
1832
            else {
1833
                video_enc->rc_override[i].qscale         = 0;
1834
                video_enc->rc_override[i].quality_factor = -q/100.0;
1835
            }
1836
            p = strchr(p, '/');
1837
            if (p) p++;
1838
        }
1839
4593
        video_enc->rc_override_count = i;
1840
1841
4593
        if (do_psnr)
1842
            video_enc->flags|= AV_CODEC_FLAG_PSNR;
1843
1844
        /* two pass mode */
1845





4593
        MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1846
4593
        if (do_pass) {
1847
            if (do_pass & 1) {
1848
                video_enc->flags |= AV_CODEC_FLAG_PASS1;
1849
                av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1850
            }
1851
            if (do_pass & 2) {
1852
                video_enc->flags |= AV_CODEC_FLAG_PASS2;
1853
                av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1854
            }
1855
        }
1856
1857





4593
        MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1858
4593
        if (ost->logfile_prefix &&
1859
            !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1860
            exit_program(1);
1861
1862
4593
        if (do_pass) {
1863
            char logfilename[1024];
1864
            FILE *f;
1865
1866
            snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1867
                     ost->logfile_prefix ? ost->logfile_prefix :
1868
                                           DEFAULT_PASS_LOGFILENAME_PREFIX,
1869
                     i);
1870
            if (!strcmp(ost->enc->name, "libx264")) {
1871
                av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1872
            } else {
1873
                if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1874
                    char  *logbuffer = read_file(logfilename);
1875
1876
                    if (!logbuffer) {
1877
                        av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1878
                               logfilename);
1879
                        exit_program(1);
1880
                    }
1881
                    video_enc->stats_in = logbuffer;
1882
                }
1883
                if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1884
                    f = av_fopen_utf8(logfilename, "wb");
1885
                    if (!f) {
1886
                        av_log(NULL, AV_LOG_FATAL,
1887
                               "Cannot write log file '%s' for pass-1 encoding: %s\n",
1888
                               logfilename, strerror(errno));
1889
                        exit_program(1);
1890
                    }
1891
                    ost->logfile = f;
1892
                }
1893
            }
1894
        }
1895
1896





4594
        MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1897
4593
        if (ost->forced_keyframes)
1898
1
            ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1899
1900





4593
        MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1901
1902
4593
        ost->top_field_first = -1;
1903





4596
        MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1904
1905
1906
4593
        ost->avfilter = get_ost_filters(o, oc, ost);
1907
4593
        if (!ost->avfilter)
1908
            exit_program(1);
1909
    } else {
1910





171
        MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1911
    }
1912
1913
4764
    if (ost->stream_copy)
1914
171
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1915
1916
4764
    return ost;
1917
}
1918
1919
1208
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1920
{
1921
    int n;
1922
    AVStream *st;
1923
    OutputStream *ost;
1924
    AVCodecContext *audio_enc;
1925
1926
1208
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1927
1208
    st  = ost->st;
1928
1929
1208
    audio_enc = ost->enc_ctx;
1930
1208
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1931
1932





1209
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1933





1606
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1934
1935
1208
    if (!ost->stream_copy) {
1936
1103
        char *sample_fmt = NULL;
1937
1938





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





1103
        MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1941
1103
        if (sample_fmt &&
1942
            (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1943
            av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1944
            exit_program(1);
1945
        }
1946
1947





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





1103
        MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1950
1103
        ost->apad = av_strdup(ost->apad);
1951
1952
1103
        ost->avfilter = get_ost_filters(o, oc, ost);
1953
1103
        if (!ost->avfilter)
1954
            exit_program(1);
1955
1956
        /* check for channel mapping for this audio stream */
1957
1113
        for (n = 0; n < o->nb_audio_channel_maps; n++) {
1958
10
            AudioChannelMap *map = &o->audio_channel_maps[n];
1959

10
            if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1960

10
                (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1961
                InputStream *ist;
1962
1963
10
                if (map->channel_idx == -1) {
1964
1
                    ist = NULL;
1965
9
                } else if (ost->source_index < 0) {
1966
                    av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1967
                           ost->file_index, ost->st->index);
1968
                    continue;
1969
                } else {
1970
9
                    ist = input_streams[ost->source_index];
1971
                }
1972
1973

10
                if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1974
10
                    if (av_reallocp_array(&ost->audio_channels_map,
1975
10
                                          ost->audio_channels_mapped + 1,
1976
                                          sizeof(*ost->audio_channels_map)
1977
                                          ) < 0 )
1978
                        exit_program(1);
1979
1980
10
                    ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1981
                }
1982
            }
1983
        }
1984
    }
1985
1986
1208
    if (ost->stream_copy)
1987
105
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1988
1989
1208
    return ost;
1990
}
1991
1992
10
static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1993
{
1994
    OutputStream *ost;
1995
1996
10
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1997
10
    if (!ost->stream_copy) {
1998
        av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1999
        exit_program(1);
2000
    }
2001
2002
10
    return ost;
2003
}
2004
2005
static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2006
{
2007
    OutputStream *ost;
2008
2009
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
2010
    if (!ost->stream_copy) {
2011
        av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
2012
        exit_program(1);
2013
    }
2014
2015
    return ost;
2016
}
2017
2018
1
static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2019
{
2020
1
    OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
2021
1
    ost->stream_copy = 1;
2022
1
    ost->finished    = 1;
2023
1
    return ost;
2024
}
2025
2026
37
static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2027
{
2028
    AVStream *st;
2029
    OutputStream *ost;
2030
    AVCodecContext *subtitle_enc;
2031
2032
37
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
2033
37
    st  = ost->st;
2034
37
    subtitle_enc = ost->enc_ctx;
2035
2036
37
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
2037
2038





37
    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2039
2040
37
    if (!ost->stream_copy) {
2041
30
        char *frame_size = NULL;
2042
2043





30
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
2044

30
        if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
2045
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2046
            exit_program(1);
2047
        }
2048
    }
2049
2050
37
    return ost;
2051
}
2052
2053
/* arg format is "output-stream-index:streamid-value". */
2054
static int opt_streamid(void *optctx, const char *opt, const char *arg)
2055
{
2056
    OptionsContext *o = optctx;
2057
    int idx;
2058
    char *p;
2059
    char idx_str[16];
2060
2061
    av_strlcpy(idx_str, arg, sizeof(idx_str));
2062
    p = strchr(idx_str, ':');
2063
    if (!p) {
2064
        av_log(NULL, AV_LOG_FATAL,
2065
               "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2066
               arg, opt);
2067
        exit_program(1);
2068
    }
2069
    *p++ = '\0';
2070
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2071
    o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2072
    o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2073
    return 0;
2074
}
2075
2076
10
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2077
{
2078
10
    AVFormatContext *is = ifile->ctx;
2079
10
    AVFormatContext *os = ofile->ctx;
2080
    AVChapter **tmp;
2081
    int i;
2082
2083
10
    tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2084
10
    if (!tmp)
2085
        return AVERROR(ENOMEM);
2086
10
    os->chapters = tmp;
2087
2088
20
    for (i = 0; i < is->nb_chapters; i++) {
2089
10
        AVChapter *in_ch = is->chapters[i], *out_ch;
2090
10
        int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2091
10
        int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
2092
10
                                       AV_TIME_BASE_Q, in_ch->time_base);
2093
10
        int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2094
                           av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2095
2096
2097
10
        if (in_ch->end < ts_off)
2098
            continue;
2099

10
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2100
            break;
2101
2102
10
        out_ch = av_mallocz(sizeof(AVChapter));
2103
10
        if (!out_ch)
2104
            return AVERROR(ENOMEM);
2105
2106
10
        out_ch->id        = in_ch->id;
2107
10
        out_ch->time_base = in_ch->time_base;
2108
10
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
2109
10
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
2110
2111
10
        if (copy_metadata)
2112
10
            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2113
2114
10
        os->chapters[os->nb_chapters++] = out_ch;
2115
    }
2116
10
    return 0;
2117
}
2118
2119
77
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2120
                               AVFormatContext *oc)
2121
{
2122
    OutputStream *ost;
2123
2124
77
    switch (ofilter->type) {
2125
62
    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2126
15
    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2127
    default:
2128
        av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2129
               "currently.\n");
2130
        exit_program(1);
2131
    }
2132
2133
77
    ost->source_index = -1;
2134
77
    ost->filter       = ofilter;
2135
2136
77
    ofilter->ost      = ost;
2137
77
    ofilter->format   = -1;
2138
2139
77
    if (ost->stream_copy) {
2140
        av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2141
               "which is fed from a complex filtergraph. Filtering and streamcopy "
2142
               "cannot be used together.\n", ost->file_index, ost->index);
2143
        exit_program(1);
2144
    }
2145
2146

77
    if (ost->avfilter && (ost->filters || ost->filters_script)) {
2147
        const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2148
        av_log(NULL, AV_LOG_ERROR,
2149
               "%s '%s' was specified through the %s option "
2150
               "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2151
               "%s and -filter_complex cannot be used together for the same stream.\n",
2152
               ost->filters ? "Filtergraph" : "Filtergraph script",
2153
               ost->filters ? ost->filters : ost->filters_script,
2154
               opt, ost->file_index, ost->index, opt);
2155
        exit_program(1);
2156
    }
2157
2158
77
    avfilter_inout_free(&ofilter->out_tmp);
2159
77
}
2160
2161
5872
static int init_complex_filters(void)
2162
{
2163
5872
    int i, ret = 0;
2164
2165
5946
    for (i = 0; i < nb_filtergraphs; i++) {
2166
74
        ret = init_complex_filtergraph(filtergraphs[i]);
2167
74
        if (ret < 0)
2168
            return ret;
2169
    }
2170
5872
    return 0;
2171
}
2172
2173
5873
static int open_output_file(OptionsContext *o, const char *filename)
2174
{
2175
    AVFormatContext *oc;
2176
    int i, j, err;
2177
    OutputFile *of;
2178
    OutputStream *ost;
2179
    InputStream  *ist;
2180
5873
    AVDictionary *unused_opts = NULL;
2181
5873
    AVDictionaryEntry *e = NULL;
2182
5873
    int format_flags = 0;
2183
2184

5873
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2185
        o->stop_time = INT64_MAX;
2186
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2187
    }
2188
2189

5873
    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2190
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2191
        if (o->stop_time <= start_time) {
2192
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2193
            exit_program(1);
2194
        } else {
2195
            o->recording_time = o->stop_time - start_time;
2196
        }
2197
    }
2198
2199
5873
    GROW_ARRAY(output_files, nb_output_files);
2200
5873
    of = av_mallocz(sizeof(*of));
2201
5873
    if (!of)
2202
        exit_program(1);
2203
5873
    output_files[nb_output_files - 1] = of;
2204
2205
5873
    of->ost_index      = nb_output_streams;
2206
5873
    of->recording_time = o->recording_time;
2207
5873
    of->start_time     = o->start_time;
2208
5873
    of->limit_filesize = o->limit_filesize;
2209
5873
    of->shortest       = o->shortest;
2210
5873
    av_dict_copy(&of->opts, o->g->format_opts, 0);
2211
2212
5873
    if (!strcmp(filename, "-"))
2213
2192
        filename = "pipe:";
2214
2215
5873
    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2216
5873
    if (!oc) {
2217
        print_error(filename, err);
2218
        exit_program(1);
2219
    }
2220
2221
5873
    of->ctx = oc;
2222
5873
    if (o->recording_time != INT64_MAX)
2223
126
        oc->duration = o->recording_time;
2224
2225
5873
    oc->interrupt_callback = int_cb;
2226
2227
5873
    e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2228
5873
    if (e) {
2229
3340
        const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2230
3340
        av_opt_eval_flags(oc, o, e->value, &format_flags);
2231
    }
2232
5873
    if (o->bitexact) {
2233
1618
        format_flags |= AVFMT_FLAG_BITEXACT;
2234
1618
        oc->flags    |= AVFMT_FLAG_BITEXACT;
2235
    }
2236
2237
    /* create streams for all unlabeled output pads */
2238
5948
    for (i = 0; i < nb_filtergraphs; i++) {
2239
75
        FilterGraph *fg = filtergraphs[i];
2240
153
        for (j = 0; j < fg->nb_outputs; j++) {
2241
78
            OutputFilter *ofilter = fg->outputs[j];
2242
2243

78
            if (!ofilter->out_tmp || ofilter->out_tmp->name)
2244
4
                continue;
2245
2246

74
            switch (ofilter->type) {
2247
60
            case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2248
14
            case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2249
            case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2250
            }
2251
74
            init_output_filter(ofilter, o, oc);
2252
        }
2253
    }
2254
2255
5873
    if (!o->nb_stream_maps) {
2256
5828
        char *subtitle_codec_name = NULL;
2257
        /* pick the "best" stream of each type */
2258
2259
        /* video: highest resolution */
2260

5828
        if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2261
4921
            int area = 0, idx = -1;
2262
4921
            int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2263
10121
            for (i = 0; i < nb_input_streams; i++) {
2264
                int new_area;
2265
5200
                ist = input_streams[i];
2266
5200
                new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2267
5200
                           + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2268
5200
                if (ist->user_set_discard == AVDISCARD_ALL)
2269
                    continue;
2270

5200
                if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2271
8
                    new_area = 1;
2272

5200
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2273
                    new_area > area) {
2274

4679
                    if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2275
                        continue;
2276
4679
                    area = new_area;
2277
4679
                    idx = i;
2278
                }
2279
            }
2280
4921
            if (idx >= 0)
2281
4679
                new_video_stream(o, oc, idx);
2282
        }
2283
2284
        /* audio: most channels */
2285

5828
        if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2286
4936
            int best_score = 0, idx = -1;
2287
10048
            for (i = 0; i < nb_input_streams; i++) {
2288
                int score;
2289
5112
                ist = input_streams[i];
2290
5112
                score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2291
5112
                        + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2292
5112
                if (ist->user_set_discard == AVDISCARD_ALL)
2293
                    continue;
2294

5112
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2295
                    score > best_score) {
2296
1156
                    best_score = score;
2297
1156
                    idx = i;
2298
                }
2299
            }
2300
4936
            if (idx >= 0)
2301
1156
                new_audio_stream(o, oc, idx);
2302
        }
2303
2304
        /* subtitles: pick first */
2305

9215
        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2306

5828
        if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2307
56
            for (i = 0; i < nb_input_streams; i++)
2308
48
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2309
                    AVCodecDescriptor const *input_descriptor =
2310
35
                        avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2311
35
                    AVCodecDescriptor const *output_descriptor = NULL;
2312
                    AVCodec const *output_codec =
2313
35
                        avcodec_find_encoder(oc->oformat->subtitle_codec);
2314
35
                    int input_props = 0, output_props = 0;
2315
35
                    if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2316
                        continue;
2317
35
                    if (output_codec)
2318
33
                        output_descriptor = avcodec_descriptor_get(output_codec->id);
2319
35
                    if (input_descriptor)
2320
35
                        input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2321
35
                    if (output_descriptor)
2322
33
                        output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2323
35
                    if (subtitle_codec_name ||
2324

28
                        input_props & output_props ||
2325
                        // Map dvb teletext which has neither property to any output subtitle encoder
2326
                        input_descriptor && output_descriptor &&
2327
                        (!input_descriptor->props ||
2328
                         !output_descriptor->props)) {
2329
35
                        new_subtitle_stream(o, oc, i);
2330
35
                        break;
2331
                    }
2332
                }
2333
        }
2334
        /* Data only if codec id match */
2335
5828
        if (!o->data_disable ) {
2336
5828
            enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2337

5828
            for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2338
                if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2339
                    continue;
2340
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2341
                    && input_streams[i]->st->codecpar->codec_id == codec_id )
2342
                    new_data_stream(o, oc, i);
2343
            }
2344
        }
2345
    } else {
2346
120
        for (i = 0; i < o->nb_stream_maps; i++) {
2347
75
            StreamMap *map = &o->stream_maps[i];
2348
2349
75
            if (map->disabled)
2350
                continue;
2351
2352
75
            if (map->linklabel) {
2353
                FilterGraph *fg;
2354
3
                OutputFilter *ofilter = NULL;
2355
                int j, k;
2356
2357
3
                for (j = 0; j < nb_filtergraphs; j++) {
2358
3
                    fg = filtergraphs[j];
2359
3
                    for (k = 0; k < fg->nb_outputs; k++) {
2360
3
                        AVFilterInOut *out = fg->outputs[k]->out_tmp;
2361

3
                        if (out && !strcmp(out->name, map->linklabel)) {
2362
3
                            ofilter = fg->outputs[k];
2363
3
                            goto loop_end;
2364
                        }
2365
                    }
2366
                }
2367
loop_end:
2368
3
                if (!ofilter) {
2369
                    av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2370
                           "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2371
                    exit_program(1);
2372
                }
2373
3
                init_output_filter(ofilter, o, oc);
2374
            } else {
2375
72
                int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2376
2377
72
                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2378
72
                if (ist->user_set_discard == AVDISCARD_ALL) {
2379
                    av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2380
                           map->file_index, map->stream_index);
2381
                    exit_program(1);
2382
                }
2383

72
                if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2384
                    continue;
2385

72
                if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2386
                    continue;
2387

72
                if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2388
                    continue;
2389

72
                if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2390
                    continue;
2391
2392
72
                ost = NULL;
2393

72
                switch (ist->st->codecpar->codec_type) {
2394
23
                case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2395
37
                case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2396
2
                case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2397
10
                case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2398
                case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2399
                case AVMEDIA_TYPE_UNKNOWN:
2400
                    if (copy_unknown_streams) {
2401
                        ost = new_unknown_stream   (o, oc, src_idx);
2402
                        break;
2403
                    }
2404
                default:
2405
                    av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2406
                           "Cannot map stream #%d:%d - unsupported type.\n",
2407
                           map->file_index, map->stream_index);
2408
                    if (!ignore_unknown_streams) {
2409
                        av_log(NULL, AV_LOG_FATAL,
2410
                               "If you want unsupported types ignored instead "
2411
                               "of failing, please use the -ignore_unknown option\n"
2412
                               "If you want them copied, please use -copy_unknown\n");
2413
                        exit_program(1);
2414
                    }
2415
                }
2416
72
                if (ost)
2417
72
                    ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2418
72
                                                  + map->sync_stream_index];
2419
            }
2420
        }
2421
    }
2422
2423
    /* handle attached files */
2424
5874
    for (i = 0; i < o->nb_attachments; i++) {
2425
        AVIOContext *pb;
2426
        uint8_t *attachment;
2427
        const char *p;
2428
        int64_t len;
2429
2430
1
        if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2431
            av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2432
                   o->attachments[i]);
2433
            exit_program(1);
2434
        }
2435
1
        if ((len = avio_size(pb)) <= 0) {
2436
            av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2437
                   o->attachments[i]);
2438
            exit_program(1);
2439
        }
2440
1
        if (!(attachment = av_malloc(len))) {
2441
            av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2442
                   o->attachments[i]);
2443
            exit_program(1);
2444
        }
2445
1
        avio_read(pb, attachment, len);
2446
2447
1
        ost = new_attachment_stream(o, oc, -1);
2448
1
        ost->stream_copy               = 0;
2449
1
        ost->attachment_filename       = o->attachments[i];
2450
1
        ost->st->codecpar->extradata      = attachment;
2451
1
        ost->st->codecpar->extradata_size = len;
2452
2453
1
        p = strrchr(o->attachments[i], '/');
2454

1
        av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2455
1
        avio_closep(&pb);
2456
    }
2457
2458
#if FF_API_LAVF_AVCTX
2459
11893
    for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2460
        AVDictionaryEntry *e;
2461
6020
        ost = output_streams[i];
2462
2463

6020
        if ((ost->stream_copy || ost->attachment_filename)
2464
294
            && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2465

65
            && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2466
65
            if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2467
                exit_program(1);
2468
    }
2469
#endif
2470
2471

5873
    if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2472
        av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2473
        av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2474
        exit_program(1);
2475
    }
2476
2477
    /* check if all codec options have been used */
2478
5873
    unused_opts = strip_specifiers(o->g->codec_opts);
2479
11893
    for (i = of->ost_index; i < nb_output_streams; i++) {
2480
6020
        e = NULL;
2481
19761
        while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2482
                                AV_DICT_IGNORE_SUFFIX)))
2483
13741
            av_dict_set(&unused_opts, e->key, NULL, 0);
2484
    }
2485
2486
5873
    e = NULL;
2487
6123
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2488
250
        const AVClass *class = avcodec_get_class();
2489
250
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2490
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2491
250
        const AVClass *fclass = avformat_get_class();
2492
250
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2493
                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2494

250
        if (!option || foption)
2495
9
            continue;
2496
2497
2498
249
        if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2499
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2500
                   "output file #%d (%s) is not an encoding option.\n", e->key,
2501
                   option->help ? option->help : "", nb_output_files - 1,
2502
                   filename);
2503
            exit_program(1);
2504
        }
2505
2506
        // gop_timecode is injected by generic code but not always used
2507
249
        if (!strcmp(e->key, "gop_timecode"))
2508
8
            continue;
2509
2510
241
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2511
               "output file #%d (%s) has not been used for any stream. The most "
2512
               "likely reason is either wrong type (e.g. a video option with "
2513
               "no video streams) or that it is a private option of some encoder "
2514
               "which was not actually used for any stream.\n", e->key,
2515
241
               option->help ? option->help : "", nb_output_files - 1, filename);
2516
    }
2517
5873
    av_dict_free(&unused_opts);
2518
2519
    /* set the decoding_needed flags and create simple filtergraphs */
2520
11893
    for (i = of->ost_index; i < nb_output_streams; i++) {
2521
6020
        OutputStream *ost = output_streams[i];
2522
2523

6020
        if (ost->encoding_needed && ost->source_index >= 0) {
2524
5649
            InputStream *ist = input_streams[ost->source_index];
2525
5649
            ist->decoding_needed |= DECODING_FOR_OST;
2526
2527
5649
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2528
1118
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2529
5619
                err = init_simple_filtergraph(ist, ost);
2530
5619
                if (err < 0) {
2531
                    av_log(NULL, AV_LOG_ERROR,
2532
                           "Error initializing a simple filtergraph between streams "
2533
                           "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2534
                           nb_output_files - 1, ost->st->index);
2535
                    exit_program(1);
2536
                }
2537
            }
2538
        }
2539
2540
        /* set the filter output constraints */
2541
6020
        if (ost->filter) {
2542
5696
            OutputFilter *f = ost->filter;
2543
            int count;
2544
5696
            switch (ost->enc_ctx->codec_type) {
2545
4593
            case AVMEDIA_TYPE_VIDEO:
2546
4593
                f->frame_rate = ost->frame_rate;
2547
4593
                f->width      = ost->enc_ctx->width;
2548
4593
                f->height     = ost->enc_ctx->height;
2549
4593
                if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2550
3296
                    f->format = ost->enc_ctx->pix_fmt;
2551
1297
                } else if (ost->enc->pix_fmts) {
2552
290
                    count = 0;
2553
1474
                    while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2554
1184
                        count++;
2555
290
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2556
290
                    if (!f->formats)
2557
                        exit_program(1);
2558
290
                    memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2559
                }
2560
4593
                break;
2561
1103
            case AVMEDIA_TYPE_AUDIO:
2562
1103
                if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2563
                    f->format = ost->enc_ctx->sample_fmt;
2564
1103
                } else if (ost->enc->sample_fmts) {
2565
1103
                    count = 0;
2566
2243
                    while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2567
1140
                        count++;
2568
1103
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2569
1103
                    if (!f->formats)
2570
                        exit_program(1);
2571
1103
                    memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2572
                }
2573
1103
                if (ost->enc_ctx->sample_rate) {
2574
25
                    f->sample_rate = ost->enc_ctx->sample_rate;
2575
1078
                } else if (ost->enc->supported_samplerates) {
2576
29
                    count = 0;
2577
281
                    while (ost->enc->supported_samplerates[count])
2578
252
                        count++;
2579
29
                    f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2580
29
                    if (!f->sample_rates)
2581
                        exit_program(1);
2582
29
                    memcpy(f->sample_rates, ost->enc->supported_samplerates,
2583
29
                           (count + 1) * sizeof(*f->sample_rates));
2584
                }
2585
1103
                if (ost->enc_ctx->channels) {
2586
12
                    f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2587
1091
                } else if (ost->enc->channel_layouts) {
2588
42
                    count = 0;
2589
280
                    while (ost->enc->channel_layouts[count])
2590
238
                        count++;
2591
42
                    f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2592
42
                    if (!f->channel_layouts)
2593
                        exit_program(1);
2594
42
                    memcpy(f->channel_layouts, ost->enc->channel_layouts,
2595
42
                           (count + 1) * sizeof(*f->channel_layouts));
2596
                }
2597
1103
                break;
2598
            }
2599
6020
        }
2600
    }
2601
2602
    /* check filename in case of an image number is expected */
2603
5873
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2604
        if (!av_filename_number_test(oc->url)) {
2605
            print_error(oc->url, AVERROR(EINVAL));
2606
            exit_program(1);
2607
        }
2608
    }
2609
2610

5873
    if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2611
        av_log(NULL, AV_LOG_ERROR,
2612
               "No input streams but output needs an input stream\n");
2613
        exit_program(1);
2614
    }
2615
2616
5873
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2617
        /* test if it already exists to avoid losing precious files */
2618
5820
        assert_file_overwrite(filename);
2619
2620
        /* open the file */
2621
5820
        if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2622
5820
                              &oc->interrupt_callback,
2623
                              &of->opts)) < 0) {
2624
            print_error(filename, err);
2625
            exit_program(1);
2626
        }
2627

53
    } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2628
        assert_file_overwrite(filename);
2629
2630
5873
    if (o->mux_preload) {
2631
        av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2632
    }
2633
5873
    oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2634
2635
    /* copy metadata */
2636
5878
    for (i = 0; i < o->nb_metadata_map; i++) {
2637
        char *p;
2638
5
        int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2639
2640
5
        if (in_file_index >= nb_input_files) {
2641
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2642
            exit_program(1);
2643
        }
2644

8
        copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2645
                      in_file_index >= 0 ?
2646
3
                      input_files[in_file_index]->ctx : NULL, o);
2647
    }
2648
2649
    /* copy chapters */
2650
5873
    if (o->chapters_input_file >= nb_input_files) {
2651
5873
        if (o->chapters_input_file == INT_MAX) {
2652
            /* copy chapters from the first input file that has them*/
2653
5873
            o->chapters_input_file = -1;
2654
11768
            for (i = 0; i < nb_input_files; i++)
2655
5905
                if (input_files[i]->ctx->nb_chapters) {
2656
10
                    o->chapters_input_file = i;
2657
10
                    break;
2658
                }
2659
        } else {
2660
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2661
                   o->chapters_input_file);
2662
            exit_program(1);
2663
        }
2664
    }
2665
5873
    if (o->chapters_input_file >= 0)
2666
10
        copy_chapters(input_files[o->chapters_input_file], of,
2667
10
                      !o->metadata_chapters_manual);
2668
2669
    /* copy global metadata by default */
2670

5873
    if (!o->metadata_global_manual && nb_input_files){
2671
5833
        av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2672
                     AV_DICT_DONT_OVERWRITE);
2673
5833
        if(o->recording_time != INT64_MAX)
2674
122
            av_dict_set(&oc->metadata, "duration", NULL, 0);
2675
5833
        av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2676
    }
2677
5873
    if (!o->metadata_streams_manual)
2678
11889
        for (i = of->ost_index; i < nb_output_streams; i++) {
2679
            InputStream *ist;
2680
6017
            if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2681
78
                continue;
2682
5939
            ist = input_streams[output_streams[i]->source_index];
2683
5939
            av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2684
5939
            if (!output_streams[i]->stream_copy) {
2685
5646
                av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2686
            }
2687
        }
2688
2689
    /* process manually set programs */
2690
5873
    for (i = 0; i < o->nb_program; i++) {
2691
        const char *p = o->program[i].u.str;
2692
        int progid = i+1;
2693
        AVProgram *program;
2694
2695
        while(*p) {
2696
            const char *p2 = av_get_token(&p, ":");
2697
            const char *to_dealloc = p2;
2698
            char *key;
2699
            if (!p2)
2700
                break;
2701
2702
            if(*p) p++;
2703
2704
            key = av_get_token(&p2, "=");
2705
            if (!key || !*p2) {
2706
                av_freep(&to_dealloc);
2707
                av_freep(&key);
2708
                break;
2709
            }
2710
            p2++;
2711
2712
            if (!strcmp(key, "program_num"))
2713
                progid = strtol(p2, NULL, 0);
2714
            av_freep(&to_dealloc);
2715
            av_freep(&key);
2716
        }
2717
2718
        program = av_new_program(oc, progid);
2719
2720
        p = o->program[i].u.str;
2721
        while(*p) {
2722
            const char *p2 = av_get_token(&p, ":");
2723
            const char *to_dealloc = p2;
2724
            char *key;
2725
            if (!p2)
2726
                break;
2727
            if(*p) p++;
2728
2729
            key = av_get_token(&p2, "=");
2730
            if (!key) {
2731
                av_log(NULL, AV_LOG_FATAL,
2732
                       "No '=' character in program string %s.\n",
2733
                       p2);
2734
                exit_program(1);
2735
            }
2736
            if (!*p2)
2737
                exit_program(1);
2738
            p2++;
2739
2740
            if (!strcmp(key, "title")) {
2741
                av_dict_set(&program->metadata, "title", p2, 0);
2742
            } else if (!strcmp(key, "program_num")) {
2743
            } else if (!strcmp(key, "st")) {
2744
                int st_num = strtol(p2, NULL, 0);
2745
                av_program_add_stream_index(oc, progid, st_num);
2746
            } else {
2747
                av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2748
                exit_program(1);
2749
            }
2750
            av_freep(&to_dealloc);
2751
            av_freep(&key);
2752
        }
2753
    }
2754
2755
    /* process manually set metadata */
2756
6015
    for (i = 0; i < o->nb_metadata; i++) {
2757
        AVDictionary **m;
2758
        char type, *val;
2759
        const char *stream_spec;
2760
142
        int index = 0, j, ret = 0;
2761
2762
142
        val = strchr(o->metadata[i].u.str, '=');
2763
142
        if (!val) {
2764
            av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2765
                   o->metadata[i].u.str);
2766
            exit_program(1);
2767
        }
2768
142
        *val++ = 0;
2769
2770
142
        parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2771
142
        if (type == 's') {
2772
19
            for (j = 0; j < oc->nb_streams; j++) {
2773
11
                ost = output_streams[nb_output_streams - oc->nb_streams + j];
2774
11
                if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2775
8
                    if (!strcmp(o->metadata[i].u.str, "rotate")) {
2776
                        char *tail;
2777
1
                        double theta = av_strtod(val, &tail);
2778
1
                        if (!*tail) {
2779
1
                            ost->rotate_overridden = 1;
2780
1
                            ost->rotate_override_value = theta;
2781
                        }
2782
                    } else {
2783
7
                        av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2784
                    }
2785
3
                } else if (ret < 0)
2786
                    exit_program(1);
2787
            }
2788
        }
2789
        else {
2790

134
            switch (type) {
2791
134
            case 'g':
2792
134
                m = &oc->metadata;
2793
134
                break;
2794
            case 'c':
2795
                if (index < 0 || index >= oc->nb_chapters) {
2796
                    av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2797
                    exit_program(1);
2798
                }
2799
                m = &oc->chapters[index]->metadata;
2800
                break;
2801
            case 'p':
2802
                if (index < 0 || index >= oc->nb_programs) {
2803
                    av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2804
                    exit_program(1);
2805
                }
2806
                m = &oc->programs[index]->metadata;
2807
                break;
2808
            default:
2809
                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2810
                exit_program(1);
2811
            }
2812
134
            av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2813
        }
2814
    }
2815
2816
5873
    return 0;
2817
}
2818
2819
static int opt_target(void *optctx, const char *opt, const char *arg)
2820
{
2821
    OptionsContext *o = optctx;
2822
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2823
    static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2824
2825
    if (!strncmp(arg, "pal-", 4)) {
2826
        norm = PAL;
2827
        arg += 4;
2828
    } else if (!strncmp(arg, "ntsc-", 5)) {
2829
        norm = NTSC;
2830
        arg += 5;
2831
    } else if (!strncmp(arg, "film-", 5)) {
2832
        norm = FILM;
2833
        arg += 5;
2834
    } else {
2835
        /* Try to determine PAL/NTSC by peeking in the input files */
2836
        if (nb_input_files) {
2837
            int i, j;
2838
            for (j = 0; j < nb_input_files; j++) {
2839
                for (i = 0; i < input_files[j]->nb_streams; i++) {
2840
                    AVStream *st = input_files[j]->ctx->streams[i];
2841
                    int64_t fr;
2842
                    if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2843
                        continue;
2844
                    fr = st->time_base.den * 1000LL / st->time_base.num;
2845
                    if (fr == 25000) {
2846
                        norm = PAL;
2847
                        break;
2848
                    } else if ((fr == 29970) || (fr == 23976)) {
2849
                        norm = NTSC;
2850
                        break;
2851
                    }
2852
                }
2853
                if (norm != UNKNOWN)
2854
                    break;
2855
            }
2856
        }
2857
        if (norm != UNKNOWN)
2858
            av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2859
    }
2860
2861
    if (norm == UNKNOWN) {
2862
        av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2863
        av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2864
        av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2865
        exit_program(1);
2866
    }
2867
2868
    if (!strcmp(arg, "vcd")) {
2869
        opt_video_codec(o, "c:v", "mpeg1video");
2870
        opt_audio_codec(o, "c:a", "mp2");
2871
        parse_option(o, "f", "vcd", options);
2872
2873
        parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2874
        parse_option(o, "r", frame_rates[norm], options);
2875
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2876
2877
        opt_default(NULL, "b:v", "1150000");
2878
        opt_default(NULL, "maxrate:v", "1150000");
2879
        opt_default(NULL, "minrate:v", "1150000");
2880
        opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2881
2882
        opt_default(NULL, "b:a", "224000");
2883
        parse_option(o, "ar", "44100", options);
2884
        parse_option(o, "ac", "2", options);
2885
2886
        opt_default(NULL, "packetsize", "2324");
2887
        opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2888
2889
        /* We have to offset the PTS, so that it is consistent with the SCR.
2890
           SCR starts at 36000, but the first two packs contain only padding
2891
           and the first pack from the other stream, respectively, may also have
2892
           been written before.
2893
           So the real data starts at SCR 36000+3*1200. */
2894
        o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2895
    } else if (!strcmp(arg, "svcd")) {
2896
2897
        opt_video_codec(o, "c:v", "mpeg2video");
2898
        opt_audio_codec(o, "c:a", "mp2");
2899
        parse_option(o, "f", "svcd", options);
2900
2901
        parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2902
        parse_option(o, "r", frame_rates[norm], options);
2903
        parse_option(o, "pix_fmt", "yuv420p", options);
2904
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2905
2906
        opt_default(NULL, "b:v", "2040000");
2907
        opt_default(NULL, "maxrate:v", "2516000");
2908
        opt_default(NULL, "minrate:v", "0"); // 1145000;
2909
        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2910
        opt_default(NULL, "scan_offset", "1");
2911
2912
        opt_default(NULL, "b:a", "224000");
2913
        parse_option(o, "ar", "44100", options);
2914
2915
        opt_default(NULL, "packetsize", "2324");
2916
2917
    } else if (!strcmp(arg, "dvd")) {
2918
2919
        opt_video_codec(o, "c:v", "mpeg2video");
2920
        opt_audio_codec(o, "c:a", "ac3");
2921
        parse_option(o, "f", "dvd", options);
2922
2923
        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2924
        parse_option(o, "r", frame_rates[norm], options);
2925
        parse_option(o, "pix_fmt", "yuv420p", options);
2926
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2927
2928
        opt_default(NULL, "b:v", "6000000");
2929
        opt_default(NULL, "maxrate:v", "9000000");
2930
        opt_default(NULL, "minrate:v", "0"); // 1500000;
2931
        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2932
2933
        opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2934
        opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2935
2936
        opt_default(NULL, "b:a", "448000");
2937
        parse_option(o, "ar", "48000", options);
2938
2939
    } else if (!strncmp(arg, "dv", 2)) {
2940
2941
        parse_option(o, "f", "dv", options);
2942
2943
        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2944
        parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2945
                          norm == PAL ? "yuv420p" : "yuv411p", options);
2946
        parse_option(o, "r", frame_rates[norm], options);
2947
2948
        parse_option(o, "ar", "48000", options);
2949
        parse_option(o, "ac", "2", options);
2950
2951
    } else {
2952
        av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2953
        return AVERROR(EINVAL);
2954
    }
2955
2956
    av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2957
    av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2958
2959
    return 0;
2960
}
2961
2962
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2963
{
2964
    av_free (vstats_filename);
2965
    vstats_filename = av_strdup (arg);
2966
    return 0;
2967
}
2968
2969
static int opt_vstats(void *optctx, const char *opt, const char *arg)
2970
{
2971
    char filename[40];
2972
    time_t today2 = time(NULL);
2973
    struct tm *today = localtime(&today2);
2974
2975
    if (!today) { // maybe tomorrow
2976
        av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2977
        exit_program(1);
2978
    }
2979
2980
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2981
             today->tm_sec);
2982
    return opt_vstats_file(NULL, opt, filename);
2983
}
2984
2985
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2986
{
2987
    OptionsContext *o = optctx;
2988
    return parse_option(o, "frames:v", arg, options);
2989
}
2990
2991
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2992
{
2993
    OptionsContext *o = optctx;
2994
    return parse_option(o, "frames:a", arg, options);
2995
}
2996
2997
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2998
{
2999
    OptionsContext *o = optctx;
3000
    return parse_option(o, "frames:d", arg, options);
3001
}
3002
3003
2
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
3004
{
3005
    int ret;
3006
2
    AVDictionary *cbak = codec_opts;
3007
2
    AVDictionary *fbak = format_opts;
3008
2
    codec_opts = NULL;
3009
2
    format_opts = NULL;
3010
3011
2
    ret = opt_default(NULL, opt, arg);
3012
3013
2
    av_dict_copy(&o->g->codec_opts , codec_opts, 0);
3014
2
    av_dict_copy(&o->g->format_opts, format_opts, 0);
3015
2
    av_dict_free(&codec_opts);
3016
2
    av_dict_free(&format_opts);
3017
2
    codec_opts = cbak;
3018
2
    format_opts = fbak;
3019
3020
2
    return ret;
3021
}
3022
3023
static int opt_preset(void *optctx, const char *opt, const char *arg)
3024
{
3025
    OptionsContext *o = optctx;
3026
    FILE *f=NULL;
3027
    char filename[1000], line[1000], tmp_line[1000];
3028
    const char *codec_name = NULL;
3029
3030
    tmp_line[0] = *opt;
3031
    tmp_line[1] = 0;
3032
    MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
3033
3034
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
3035
        if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
3036
            av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
3037
        }else
3038
            av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3039
        exit_program(1);
3040
    }
3041
3042
    while (fgets(line, sizeof(line), f)) {
3043
        char *key = tmp_line, *value, *endptr;
3044
3045
        if (strcspn(line, "#\n\r") == 0)
3046
            continue;
3047
        av_strlcpy(tmp_line, line, sizeof(tmp_line));
3048
        if (!av_strtok(key,   "=",    &value) ||
3049
            !av_strtok(value, "\r\n", &endptr)) {
3050
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3051
            exit_program(1);
3052
        }
3053
        av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3054
3055
        if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
3056
        else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
3057
        else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3058
        else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
3059
        else if (opt_default_new(o, key, value) < 0) {
3060
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3061
                   filename, line, key, value);
3062
            exit_program(1);
3063
        }
3064
    }
3065
3066
    fclose(f);
3067
3068
    return 0;
3069
}
3070
3071
3
static int opt_old2new(void *optctx, const char *opt, const char *arg)
3072
{
3073
3
    OptionsContext *o = optctx;
3074
    int ret;
3075
3
    char *s = av_asprintf("%s:%c", opt + 1, *opt);
3076
3
    if (!s)
3077
        return AVERROR(ENOMEM);
3078
3
    ret = parse_option(o, s, arg, options);
3079
3
    av_free(s);
3080
3
    return ret;
3081
}
3082
3083
153
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3084
{
3085
153
    OptionsContext *o = optctx;
3086
3087
153
    if(!strcmp(opt, "ab")){
3088
1
        av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3089
1
        return 0;
3090
152
    } else if(!strcmp(opt, "b")){
3091
39
        av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3092
39
        av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3093
39
        return 0;
3094
    }
3095
113
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
3096
113
    return 0;
3097
}
3098
3099
254
static int opt_qscale(void *optctx, const char *opt, const char *arg)
3100
{
3101
254
    OptionsContext *o = optctx;
3102
    char *s;
3103
    int ret;
3104
254
    if(!strcmp(opt, "qscale")){
3105
215
        av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3106
215
        return parse_option(o, "q:v", arg, options);
3107
    }
3108
39
    s = av_asprintf("q%s", opt + 6);
3109
39
    if (!s)
3110
        return AVERROR(ENOMEM);
3111
39
    ret = parse_option(o, s, arg, options);
3112
39
    av_free(s);
3113
39
    return ret;
3114
}
3115
3116
45
static int opt_profile(void *optctx, const char *opt, const char *arg)
3117
{
3118
45
    OptionsContext *o = optctx;
3119
45
    if(!strcmp(opt, "profile")){
3120
4
        av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3121
4
        av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3122
4
        return 0;
3123
    }
3124
41
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
3125
41
    return 0;
3126
}
3127
3128
2169
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3129
{
3130
2169
    OptionsContext *o = optctx;
3131
2169
    return parse_option(o, "filter:v", arg, options);
3132
}
3133
3134
380
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3135
{
3136
380
    OptionsContext *o = optctx;
3137
380
    return parse_option(o, "filter:a", arg, options);
3138
}
3139
3140
803
static int opt_vsync(void *optctx, const char *opt, const char *arg)
3141
{
3142
803
    if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3143
799
    else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3144
798
    else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3145
795
    else if (!av_strcasecmp(arg, "drop"))