GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg_opt.c Lines: 1131 1959 57.7 %
Date: 2020-07-13 04:22:34 Branches: 892 2378 37.5 %

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_autoscale[]                 = {"autoscale", NULL};
66
static const char *opt_name_max_frames[]                = {"frames", "aframes", "vframes", "dframes", NULL};
67
static const char *opt_name_bitstream_filters[]         = {"bsf", "absf", "vbsf", NULL};
68
static const char *opt_name_codec_tags[]                = {"tag", "atag", "vtag", "stag", NULL};
69
static const char *opt_name_sample_fmts[]               = {"sample_fmt", NULL};
70
static const char *opt_name_qscale[]                    = {"q", "qscale", NULL};
71
static const char *opt_name_forced_key_frames[]         = {"forced_key_frames", NULL};
72
static const char *opt_name_force_fps[]                 = {"force_fps", NULL};
73
static const char *opt_name_frame_aspect_ratios[]       = {"aspect", NULL};
74
static const char *opt_name_rc_overrides[]              = {"rc_override", NULL};
75
static const char *opt_name_intra_matrices[]            = {"intra_matrix", NULL};
76
static const char *opt_name_inter_matrices[]            = {"inter_matrix", NULL};
77
static const char *opt_name_chroma_intra_matrices[]     = {"chroma_intra_matrix", NULL};
78
static const char *opt_name_top_field_first[]           = {"top", NULL};
79
static const char *opt_name_presets[]                   = {"pre", "apre", "vpre", "spre", NULL};
80
static const char *opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL};
81
static const char *opt_name_copy_prior_start[]          = {"copypriorss", NULL};
82
static const char *opt_name_filters[]                   = {"filter", "af", "vf", NULL};
83
static const char *opt_name_filter_scripts[]            = {"filter_script", NULL};
84
static const char *opt_name_reinit_filters[]            = {"reinit_filter", NULL};
85
static const char *opt_name_fix_sub_duration[]          = {"fix_sub_duration", NULL};
86
static const char *opt_name_canvas_sizes[]              = {"canvas_size", NULL};
87
static const char *opt_name_pass[]                      = {"pass", NULL};
88
static const char *opt_name_passlogfiles[]              = {"passlogfile", NULL};
89
static const char *opt_name_max_muxing_queue_size[]     = {"max_muxing_queue_size", NULL};
90
static const char *opt_name_guess_layout_max[]          = {"guess_layout_max", NULL};
91
static const char *opt_name_apad[]                      = {"apad", NULL};
92
static const char *opt_name_discard[]                   = {"discard", NULL};
93
static const char *opt_name_disposition[]               = {"disposition", NULL};
94
static const char *opt_name_time_bases[]                = {"time_base", NULL};
95
static const char *opt_name_enc_time_bases[]            = {"enc_time_base", NULL};
96
97
#define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
98
{\
99
    char namestr[128] = "";\
100
    const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
101
    for (i = 0; opt_name_##name[i]; i++)\
102
        av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
103
    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",\
104
           namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
105
}
106
107
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
108
{\
109
    int i, ret, matches = 0;\
110
    SpecifierOpt *so;\
111
    for (i = 0; i < o->nb_ ## name; i++) {\
112
        char *spec = o->name[i].specifier;\
113
        if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
114
            outvar = o->name[i].u.type;\
115
            so = &o->name[i];\
116
            matches++;\
117
        } else if (ret < 0)\
118
            exit_program(1);\
119
    }\
120
    if (matches > 1)\
121
       WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
122
}
123
124
#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
125
{\
126
    int i;\
127
    for (i = 0; i < o->nb_ ## name; i++) {\
128
        char *spec = o->name[i].specifier;\
129
        if (!strcmp(spec, mediatype))\
130
            outvar = o->name[i].u.type;\
131
    }\
132
}
133
134
const HWAccel hwaccels[] = {
135
#if CONFIG_VIDEOTOOLBOX
136
    { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
137
#endif
138
#if CONFIG_LIBMFX
139
    { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV },
140
#endif
141
    { 0 },
142
};
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
11940
static void uninit_options(OptionsContext *o)
188
{
189
11940
    const OptionDef *po = options;
190
    int i;
191
192
    /* all OPT_SPEC and OPT_STRING can be freed in generic way */
193
2137260
    while (po->name) {
194
2125320
        void *dst = (uint8_t*)o + po->u.off;
195
196
2125320
        if (po->flags & OPT_SPEC) {
197
561180
            SpecifierOpt **so = dst;
198
561180
            int i, *count = (int*)(so + 1);
199
585197
            for (i = 0; i < *count; i++) {
200
24017
                av_freep(&(*so)[i].specifier);
201
24017
                if (po->flags & OPT_STRING)
202
19372
                    av_freep(&(*so)[i].u.str);
203
            }
204
561180
            av_freep(so);
205
561180
            *count = 0;
206

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

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

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

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

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

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

29
        switch (*arg) {
593
17
        case 'g':
594
17
            break;
595
12
        case 's':
596

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

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

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

2
        if (type_out == 'c' || !*outspec)
633
            o->metadata_chapters_manual = 1;
634
2
        return 0;
635
    }
636
637

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

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

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



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



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

10265
    if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
731
1
        codec = encoder ? avcodec_find_encoder(desc->id) :
732
                          avcodec_find_decoder(desc->id);
733
1
        if (codec)
734
1
            av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
735
                   codec_string, codec->name, desc->name);
736
    }
737
738
10265
    if (!codec) {
739
        av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
740
        exit_program(1);
741
    }
742
10265
    if (codec->type != type) {
743
        av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
744
        exit_program(1);
745
    }
746
10265
    return codec;
747
}
748
749
12528
static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
750
{
751
12528
    char *codec_name = NULL;
752
753





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





6311
        MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
797
798
6311
        ist->autorotate = 1;
799





6311
        MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
800
801





6313
        MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
802
6311
        if (codec_tag) {
803
2
            uint32_t tag = strtol(codec_tag, &next, 0);
804
2
            if (*next)
805
2
                tag = AV_RL32(codec_tag);
806
2
            st->codecpar->codec_tag = tag;
807
        }
808
809
6311
        ist->dec = choose_decoder(o, ic, st);
810
6311
        ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
811
812
6311
        ist->reinit_filters = -1;
813





6311
        MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
814
815





6311
        MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
816
6311
        ist->user_set_discard = AVDISCARD_NONE;
817
818

6311
        if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
819

6311
            (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
820

6311
            (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
821

6311
            (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
822
                ist->user_set_discard = AVDISCARD_ALL;
823
824

6311
        if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
825
            av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
826
                    discard_str);
827
            exit_program(1);
828
        }
829
830
6311
        ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
831
832
6311
        ist->dec_ctx = avcodec_alloc_context3(ist->dec);
833
6311
        if (!ist->dec_ctx) {
834
            av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
835
            exit_program(1);
836
        }
837
838
6311
        ret = avcodec_parameters_to_context(ist->dec_ctx, par);
839
6311
        if (ret < 0) {
840
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
841
            exit_program(1);
842
        }
843
844
6311
        if (o->bitexact)
845
84
            ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
846
847

6311
        switch (par->codec_type) {
848
4849
        case AVMEDIA_TYPE_VIDEO:
849
4849
            if(!ist->dec)
850
21
                ist->dec = avcodec_find_decoder(par->codec_id);
851
#if FF_API_LOWRES
852
4849
            if (st->codec->lowres) {
853
1
                ist->dec_ctx->lowres = st->codec->lowres;
854
1
                ist->dec_ctx->width  = st->codec->width;
855
1
                ist->dec_ctx->height = st->codec->height;
856
1
                ist->dec_ctx->coded_width  = st->codec->coded_width;
857
1
                ist->dec_ctx->coded_height = st->codec->coded_height;
858
            }
859
#endif
860
861
            // avformat_find_stream_info() doesn't set this for us anymore.
862
4849
            ist->dec_ctx->framerate = st->avg_frame_rate;
863
864





4873
            MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
865

4849
            if (framerate && av_parse_video_rate(&ist->framerate,
866
                                                 framerate) < 0) {
867
                av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
868
                       framerate);
869
                exit_program(1);
870
            }
871
872
4849
            ist->top_field_first = -1;
873





4849
            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
874
875





9457
            MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
876





4849
            MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
877
                                 hwaccel_output_format, ic, st);
878
879

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

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





4849
            MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
938
4849
            if (hwaccel_device) {
939
                ist->hwaccel_device = av_strdup(hwaccel_device);
940
                if (!ist->hwaccel_device)
941
                    exit_program(1);
942
            }
943
944
4849
            ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
945
946
4849
            break;
947
1368
        case AVMEDIA_TYPE_AUDIO:
948
1368
            ist->guess_layout_max = INT_MAX;
949





1372
            MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
950
1368
            guess_input_channel_layout(ist);
951
1368
            break;
952
93
        case AVMEDIA_TYPE_DATA:
953
        case AVMEDIA_TYPE_SUBTITLE: {
954
93
            char *canvas_size = NULL;
955
93
            if(!ist->dec)
956
48
                ist->dec = avcodec_find_decoder(par->codec_id);
957





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





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

93
            if (canvas_size &&
960
                av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
961
                av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
962
                exit_program(1);
963
            }
964
93
            break;
965
        }
966
1
        case AVMEDIA_TYPE_ATTACHMENT:
967
        case AVMEDIA_TYPE_UNKNOWN:
968
1
            break;
969
        default:
970
            abort();
971
        }
972
973
6311
        ret = avcodec_parameters_from_context(par, ist->dec_ctx);
974
6311
        if (ret < 0) {
975
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
976
            exit_program(1);
977
        }
978
    }
979
5984
}
980
981
5902
static void assert_file_overwrite(const char *filename)
982
{
983
5902
    const char *proto_name = avio_find_protocol_name(filename);
984
985

5902
    if (file_overwrite && no_file_overwrite) {
986
        fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
987
        exit_program(1);
988
    }
989
990
5902
    if (!file_overwrite) {
991

4430
        if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
992
            if (stdin_interaction && !no_file_overwrite) {
993
                fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
994
                fflush(stderr);
995
                term_exit();
996
                signal(SIGINT, SIG_DFL);
997
                if (!read_yesno()) {
998
                    av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
999
                    exit_program(1);
1000
                }
1001
                term_init();
1002
            }
1003
            else {
1004
                av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1005
                exit_program(1);
1006
            }
1007
        }
1008
    }
1009
1010

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

5985
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1072
        o->stop_time = INT64_MAX;
1073
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1074
    }
1075
1076

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

18
        if (file_iformat && file_iformat->priv_class &&
1113
9
            av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1114
                        AV_OPT_SEARCH_FAKE_OBJ)) {
1115
9
            av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1116
        }
1117
    }
1118
5985
    if (o->nb_frame_rates) {
1119
        /* set the format-level framerate option;
1120
         * this is important for video grabbers, e.g. x11 */
1121

48
        if (file_iformat && file_iformat->priv_class &&
1122
24
            av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1123
                        AV_OPT_SEARCH_FAKE_OBJ)) {
1124
24
            av_dict_set(&o->g->format_opts, "framerate",
1125
24
                        o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1126
        }
1127
    }
1128
5985
    if (o->nb_frame_sizes) {
1129
492
        av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1130
    }
1131
5985
    if (o->nb_frame_pix_fmts)
1132
497
        av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1133
1134

8356
    MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
1135

8356
    MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
1136

8356
    MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1137

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

5984
    if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1201
        av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1202
        o->start_time_eof = AV_NOPTS_VALUE;
1203
    }
1204
1205
5984
    if (o->start_time_eof != AV_NOPTS_VALUE) {
1206
        if (o->start_time_eof >= 0) {
1207
            av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1208
            exit_program(1);
1209
        }
1210
        if (ic->duration > 0) {
1211
            o->start_time = o->start_time_eof + ic->duration;
1212
            if (o->start_time < 0) {
1213
                av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1214
                o->start_time = AV_NOPTS_VALUE;
1215
            }
1216
        } else
1217
            av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1218
    }
1219
5984
    timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1220
    /* add the stream start time */
1221

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

5984
    f->ts_offset  = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1266
5984
    f->nb_streams = ic->nb_streams;
1267
5984
    f->rate_emu   = o->rate_emu;
1268
5984
    f->accurate_seek = o->accurate_seek;
1269
5984
    f->loop = o->loop;
1270
5984
    f->duration = 0;
1271
5984
    f->time_base = (AVRational){ 1, 1 };
1272
#if HAVE_THREADS
1273
5984
    f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1274
#endif
1275
1276
    /* check if all codec options have been used */
1277
5984
    unused_opts = strip_specifiers(o->g->codec_opts);
1278
12295
    for (i = f->ist_index; i < nb_input_streams; i++) {
1279
6311
        e = NULL;
1280
25660
        while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1281
                                AV_DICT_IGNORE_SUFFIX)))
1282
19349
            av_dict_set(&unused_opts, e->key, NULL, 0);
1283
    }
1284
1285
5984
    e = NULL;
1286
6246
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1287
262
        const AVClass *class = avcodec_get_class();
1288
262
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1289
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1290
262
        const AVClass *fclass = avformat_get_class();
1291
262
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1292
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1293

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

6103
    if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1381





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





5805
        MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1466
5805
        ost->autoscale = 1;
1467





5805
        MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1468

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





6104
    MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1500
6103
    if (time_base) {
1501
        AVRational q;
1502
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1503

1
            q.num <= 0 || q.den <= 0) {
1504
            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1505
            exit_program(1);
1506
        }
1507
1
        st->time_base = q;
1508
    }
1509
1510





6103
    MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1511
6103
    if (time_base) {
1512
        AVRational q;
1513
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1514
1
            q.den <= 0) {
1515
            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1516
            exit_program(1);
1517
        }
1518
1
        ost->enc_timebase = q;
1519
    }
1520
1521
6103
    ost->max_frames = INT64_MAX;
1522





17987
    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1523
10369
    for (i = 0; i<o->nb_max_frames; i++) {
1524
4272
        char *p = o->max_frames[i].specifier;
1525

4272
        if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1526
6
            av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1527
6
            break;
1528
        }
1529
    }
1530
1531
6103
    ost->copy_prior_start = -1;
1532





6103
    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1533
1534





6188
    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1535

6103
    if (bsfs && *bsfs) {
1536
85
        ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1537
85
        if (ret < 0) {
1538
            av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1539
            exit_program(1);
1540
        }
1541
    }
1542
1543





6109
    MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1544
6103
    if (codec_tag) {
1545
6
        uint32_t tag = strtol(codec_tag, &next, 0);
1546
6
        if (*next)
1547
6
            tag = AV_RL32(codec_tag);
1548
6
        ost->st->codecpar->codec_tag =
1549
6
        ost->enc_ctx->codec_tag = tag;
1550
    }
1551
1552





6389
    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1553
6103
    if (qscale >= 0) {
1554
232
        ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1555
232
        ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1556
    }
1557
1558





6103
    MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1559
6103
    ost->disposition = av_strdup(ost->disposition);
1560
1561
6103
    ost->max_muxing_queue_size = 128;
1562





6105
    MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1563
6103
    ost->max_muxing_queue_size *= sizeof(AVPacket);
1564
1565
6103
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1566
2343
        ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1567
1568
6103
    av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1569
1570
6103
    av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1571

6103
    if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1572
52
        av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1573
1574
6103
    av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1575
1576
6103
    ost->source_index = source_index;
1577
6103
    if (source_index >= 0) {
1578
6020
        ost->sync_ist = input_streams[source_index];
1579
6020
        input_streams[source_index]->discard = 0;
1580
6020
        input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1581
    }
1582
6103
    ost->last_mux_dts = AV_NOPTS_VALUE;
1583
1584
6103
    ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1585
6103
    if (!ost->muxing_queue)
1586
        exit_program(1);
1587
1588
6103
    return ost;
1589
}
1590
1591
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1592
{
1593
    int i;
1594
    const char *p = str;
1595
    for (i = 0;; i++) {
1596
        dest[i] = atoi(p);
1597
        if (i == 63)
1598
            break;
1599
        p = strchr(p, ',');
1600
        if (!p) {
1601
            av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1602
            exit_program(1);
1603
        }
1604
        p++;
1605
    }
1606
}
1607
1608
/* read file contents into a string */
1609
28
static uint8_t *read_file(const char *filename)
1610
{
1611
28
    AVIOContext *pb      = NULL;
1612
28
    AVIOContext *dyn_buf = NULL;
1613
28
    int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1614
    uint8_t buf[1024], *str;
1615
1616
28
    if (ret < 0) {
1617
        av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1618
        return NULL;
1619
    }
1620
1621
28
    ret = avio_open_dyn_buf(&dyn_buf);
1622
28
    if (ret < 0) {
1623
        avio_closep(&pb);
1624
        return NULL;
1625
    }
1626
56
    while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1627
28
        avio_write(dyn_buf, buf, ret);
1628
28
    avio_w8(dyn_buf, 0);
1629
28
    avio_closep(&pb);
1630
1631
28
    ret = avio_close_dyn_buf(dyn_buf, &str);
1632
28
    if (ret < 0)
1633
        return NULL;
1634
28
    return str;
1635
}
1636
1637
5775
static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1638
                             OutputStream *ost)
1639
{
1640
5775
    AVStream *st = ost->st;
1641
1642

5775
    if (ost->filters_script && ost->filters) {
1643
        av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1644
               "output stream #%d:%d.\n", nb_output_files, st->index);
1645
        exit_program(1);
1646
    }
1647
1648
5775
    if (ost->filters_script)
1649
4
        return read_file(ost->filters_script);
1650
5771
    else if (ost->filters)
1651
2617
        return av_strdup(ost->filters);
1652
1653
3154
    return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1654
                     "null" : "anull");
1655
}
1656
1657
280
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1658
                                     const OutputStream *ost, enum AVMediaType type)
1659
{
1660

280
    if (ost->filters_script || ost->filters) {
1661
        av_log(NULL, AV_LOG_ERROR,
1662
               "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1663
               "Filtering and streamcopy cannot be used together.\n",
1664
               ost->filters ? "Filtergraph" : "Filtergraph script",
1665
               ost->filters ? ost->filters : ost->filters_script,
1666
               av_get_media_type_string(type), ost->file_index, ost->index);
1667
        exit_program(1);
1668
    }
1669
280
}
1670
1671
4832
static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1672
{
1673
    AVStream *st;
1674
    OutputStream *ost;
1675
    AVCodecContext *video_enc;
1676
4832
    char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1677
1678
4832
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1679
4832
    st  = ost->st;
1680
4832
    video_enc = ost->enc_ctx;
1681
1682





4853
    MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1683

4832
    if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1684
        av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1685
        exit_program(1);
1686
    }
1687

4832
    if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1688
        av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1689
1690





4832
    MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1691
4832
    if (frame_aspect_ratio) {
1692
        AVRational q;
1693
        if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1694
            q.num <= 0 || q.den <= 0) {
1695
            av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1696
            exit_program(1);
1697
        }
1698
        ost->frame_aspect_ratio = q;
1699
    }
1700
1701





4835
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1702





7059
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1703
1704
4832
    if (!ost->stream_copy) {
1705
4661
        const char *p = NULL;
1706
4661
        char *frame_size = NULL;
1707
4661
        char *frame_pix_fmt = NULL;
1708
4661
        char *intra_matrix = NULL, *inter_matrix = NULL;
1709
4661
        char *chroma_intra_matrix = NULL;
1710
4661
        int do_pass = 0;
1711
        int i;
1712
1713





5276
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1714

4661
        if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1715
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1716
            exit_program(1);
1717
        }
1718
1719
4661
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1720





8017
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1721

4661
        if (frame_pix_fmt && *frame_pix_fmt == '+') {
1722
            ost->keep_pix_fmt = 1;
1723
            if (!*++frame_pix_fmt)
1724
                frame_pix_fmt = NULL;
1725
        }
1726

4661
        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1727
            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1728
            exit_program(1);
1729
        }
1730
4661
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1731
1732
4661
        if (intra_only)
1733
            video_enc->gop_size = 0;
1734





4661
        MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1735
4661
        if (intra_matrix) {
1736
            if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1737
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1738
                exit_program(1);
1739
            }
1740
            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1741
        }
1742





4661
        MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1743
4661
        if (chroma_intra_matrix) {
1744
            uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1745
            if (!p) {
1746
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1747
                exit_program(1);
1748
            }
1749
            video_enc->chroma_intra_matrix = p;
1750
            parse_matrix_coeffs(p, chroma_intra_matrix);
1751
        }
1752





4661
        MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1753
4661
        if (inter_matrix) {
1754
            if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1755
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1756
                exit_program(1);
1757
            }
1758
            parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1759
        }
1760
1761





4661
        MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1762
4661
        for (i = 0; p; i++) {
1763
            int start, end, q;
1764
            int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1765
            if (e != 3) {
1766
                av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1767
                exit_program(1);
1768
            }
1769
            video_enc->rc_override =
1770
                av_realloc_array(video_enc->rc_override,
1771
                                 i + 1, sizeof(RcOverride));
1772
            if (!video_enc->rc_override) {
1773
                av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1774
                exit_program(1);
1775
            }
1776
            video_enc->rc_override[i].start_frame = start;
1777
            video_enc->rc_override[i].end_frame   = end;
1778
            if (q > 0) {
1779
                video_enc->rc_override[i].qscale         = q;
1780
                video_enc->rc_override[i].quality_factor = 1.0;
1781
            }
1782
            else {
1783
                video_enc->rc_override[i].qscale         = 0;
1784
                video_enc->rc_override[i].quality_factor = -q/100.0;
1785
            }
1786
            p = strchr(p, '/');
1787
            if (p) p++;
1788
        }
1789
4661
        video_enc->rc_override_count = i;
1790
1791
4661
        if (do_psnr)
1792
            video_enc->flags|= AV_CODEC_FLAG_PSNR;
1793
1794
        /* two pass mode */
1795





4661
        MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1796
4661
        if (do_pass) {
1797
            if (do_pass & 1) {
1798
                video_enc->flags |= AV_CODEC_FLAG_PASS1;
1799
                av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1800
            }
1801
            if (do_pass & 2) {
1802
                video_enc->flags |= AV_CODEC_FLAG_PASS2;
1803
                av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1804
            }
1805
        }
1806
1807





4661
        MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1808
4661
        if (ost->logfile_prefix &&
1809
            !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1810
            exit_program(1);
1811
1812
4661
        if (do_pass) {
1813
            char logfilename[1024];
1814
            FILE *f;
1815
1816
            snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1817
                     ost->logfile_prefix ? ost->logfile_prefix :
1818
                                           DEFAULT_PASS_LOGFILENAME_PREFIX,
1819
                     i);
1820
            if (!strcmp(ost->enc->name, "libx264")) {
1821
                av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1822
            } else {
1823
                if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1824
                    char  *logbuffer = read_file(logfilename);
1825
1826
                    if (!logbuffer) {
1827
                        av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1828
                               logfilename);
1829
                        exit_program(1);
1830
                    }
1831
                    video_enc->stats_in = logbuffer;
1832
                }
1833
                if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1834
                    f = av_fopen_utf8(logfilename, "wb");
1835
                    if (!f) {
1836
                        av_log(NULL, AV_LOG_FATAL,
1837
                               "Cannot write log file '%s' for pass-1 encoding: %s\n",
1838
                               logfilename, strerror(errno));
1839
                        exit_program(1);
1840
                    }
1841
                    ost->logfile = f;
1842
                }
1843
            }
1844
        }
1845
1846





4662
        MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1847
4661
        if (ost->forced_keyframes)
1848
1
            ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1849
1850





4661
        MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1851
1852
4661
        ost->top_field_first = -1;
1853





4664
        MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1854
1855
1856
4661
        ost->avfilter = get_ost_filters(o, oc, ost);
1857
4661
        if (!ost->avfilter)
1858
            exit_program(1);
1859
    } else {
1860





171
        MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1861
    }
1862
1863
4832
    if (ost->stream_copy)
1864
171
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1865
1866
4832
    return ost;
1867
}
1868
1869
1223
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1870
{
1871
    int n;
1872
    AVStream *st;
1873
    OutputStream *ost;
1874
    AVCodecContext *audio_enc;
1875
1876
1223
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1877
1223
    st  = ost->st;
1878
1879
1223
    audio_enc = ost->enc_ctx;
1880
1223
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1881
1882





1224
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1883





1621
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1884
1885
1223
    if (!ost->stream_copy) {
1886
1114
        char *sample_fmt = NULL;
1887
1888





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





1114
        MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1891
1114
        if (sample_fmt &&
1892
            (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1893
            av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1894
            exit_program(1);
1895
        }
1896
1897





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





1114
        MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1900
1114
        ost->apad = av_strdup(ost->apad);
1901
1902
1114
        ost->avfilter = get_ost_filters(o, oc, ost);
1903
1114
        if (!ost->avfilter)
1904
            exit_program(1);
1905
1906
        /* check for channel mapping for this audio stream */
1907
1124
        for (n = 0; n < o->nb_audio_channel_maps; n++) {
1908
10
            AudioChannelMap *map = &o->audio_channel_maps[n];
1909

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

10
                (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1911
                InputStream *ist;
1912
1913
10
                if (map->channel_idx == -1) {
1914
1
                    ist = NULL;
1915
9
                } else if (ost->source_index < 0) {
1916
                    av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1917
                           ost->file_index, ost->st->index);
1918
                    continue;
1919
                } else {
1920
9
                    ist = input_streams[ost->source_index];
1921
                }
1922
1923

10
                if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1924
10
                    if (av_reallocp_array(&ost->audio_channels_map,
1925
10
                                          ost->audio_channels_mapped + 1,
1926
                                          sizeof(*ost->audio_channels_map)
1927
                                          ) < 0 )
1928
                        exit_program(1);
1929
1930
10
                    ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1931
                }
1932
            }
1933
        }
1934
    }
1935
1936
1223
    if (ost->stream_copy)
1937
109
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1938
1939
1223
    return ost;
1940
}
1941
1942
10
static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1943
{
1944
    OutputStream *ost;
1945
1946
10
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1947
10
    if (!ost->stream_copy) {
1948
        av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1949
        exit_program(1);
1950
    }
1951
1952
10
    return ost;
1953
}
1954
1955
static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1956
{
1957
    OutputStream *ost;
1958
1959
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1960
    if (!ost->stream_copy) {
1961
        av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1962
        exit_program(1);
1963
    }
1964
1965
    return ost;
1966
}
1967
1968
1
static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1969
{
1970
1
    OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1971
1
    ost->stream_copy = 1;
1972
1
    ost->finished    = 1;
1973
1
    return ost;
1974
}
1975
1976
37
static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1977
{
1978
    AVStream *st;
1979
    OutputStream *ost;
1980
    AVCodecContext *subtitle_enc;
1981
1982
37
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1983
37
    st  = ost->st;
1984
37
    subtitle_enc = ost->enc_ctx;
1985
1986
37
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1987
1988





37
    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1989
1990
37
    if (!ost->stream_copy) {
1991
30
        char *frame_size = NULL;
1992
1993





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

30
        if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1995
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1996
            exit_program(1);
1997
        }
1998
    }
1999
2000
37
    return ost;
2001
}
2002
2003
/* arg format is "output-stream-index:streamid-value". */
2004
static int opt_streamid(void *optctx, const char *opt, const char *arg)
2005
{
2006
    OptionsContext *o = optctx;
2007
    int idx;
2008
    char *p;
2009
    char idx_str[16];
2010
2011
    av_strlcpy(idx_str, arg, sizeof(idx_str));
2012
    p = strchr(idx_str, ':');
2013
    if (!p) {
2014
        av_log(NULL, AV_LOG_FATAL,
2015
               "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2016
               arg, opt);
2017
        exit_program(1);
2018
    }
2019
    *p++ = '\0';
2020
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2021
    o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2022
    o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2023
    return 0;
2024
}
2025
2026
12
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2027
{
2028
12
    AVFormatContext *is = ifile->ctx;
2029
12
    AVFormatContext *os = ofile->ctx;
2030
    AVChapter **tmp;
2031
    int i;
2032
2033
12
    tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2034
12
    if (!tmp)
2035
        return AVERROR(ENOMEM);
2036
12
    os->chapters = tmp;
2037
2038
27
    for (i = 0; i < is->nb_chapters; i++) {
2039
16
        AVChapter *in_ch = is->chapters[i], *out_ch;
2040
16
        int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2041
16
        int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
2042
16
                                       AV_TIME_BASE_Q, in_ch->time_base);
2043
16
        int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2044
2
                           av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2045
2046
2047
16
        if (in_ch->end < ts_off)
2048
            continue;
2049

16
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2050
1
            break;
2051
2052
15
        out_ch = av_mallocz(sizeof(AVChapter));
2053
15
        if (!out_ch)
2054
            return AVERROR(ENOMEM);
2055
2056
15
        out_ch->id        = in_ch->id;
2057
15
        out_ch->time_base = in_ch->time_base;
2058
15
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
2059
15
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
2060
2061
15
        if (copy_metadata)
2062
15
            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2063
2064
15
        os->chapters[os->nb_chapters++] = out_ch;
2065
    }
2066
12
    return 0;
2067
}
2068
2069
82
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2070
                               AVFormatContext *oc)
2071
{
2072
    OutputStream *ost;
2073
2074
82
    switch (ofilter->type) {
2075
67
    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2076
15
    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2077
    default:
2078
        av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2079
               "currently.\n");
2080
        exit_program(1);
2081
    }
2082
2083
82
    ost->source_index = -1;
2084
82
    ost->filter       = ofilter;
2085
2086
82
    ofilter->ost      = ost;
2087
82
    ofilter->format   = -1;
2088
2089
82
    if (ost->stream_copy) {
2090
        av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2091
               "which is fed from a complex filtergraph. Filtering and streamcopy "
2092
               "cannot be used together.\n", ost->file_index, ost->index);
2093
        exit_program(1);
2094
    }
2095
2096

82
    if (ost->avfilter && (ost->filters || ost->filters_script)) {
2097
        const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2098
        av_log(NULL, AV_LOG_ERROR,
2099
               "%s '%s' was specified through the %s option "
2100
               "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2101
               "%s and -filter_complex cannot be used together for the same stream.\n",
2102
               ost->filters ? "Filtergraph" : "Filtergraph script",
2103
               ost->filters ? ost->filters : ost->filters_script,
2104
               opt, ost->file_index, ost->index, opt);
2105
        exit_program(1);
2106
    }
2107
2108
82
    avfilter_inout_free(&ofilter->out_tmp);
2109
82
}
2110
2111
5955
static int init_complex_filters(void)
2112
{
2113
5955
    int i, ret = 0;
2114
2115
6034
    for (i = 0; i < nb_filtergraphs; i++) {
2116
79
        ret = init_complex_filtergraph(filtergraphs[i]);
2117
79
        if (ret < 0)
2118
            return ret;
2119
    }
2120
5955
    return 0;
2121
}
2122
2123
5956
static int open_output_file(OptionsContext *o, const char *filename)
2124
{
2125
    AVFormatContext *oc;
2126
    int i, j, err;
2127
    OutputFile *of;
2128
    OutputStream *ost;
2129
    InputStream  *ist;
2130
5956
    AVDictionary *unused_opts = NULL;
2131
5956
    AVDictionaryEntry *e = NULL;
2132
5956
    int format_flags = 0;
2133
2134

5956
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2135
        o->stop_time = INT64_MAX;
2136
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2137
    }
2138
2139

5956
    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2140
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2141
        if (o->stop_time <= start_time) {
2142
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2143
            exit_program(1);
2144
        } else {
2145
            o->recording_time = o->stop_time - start_time;
2146
        }
2147
    }
2148
2149
5956
    GROW_ARRAY(output_files, nb_output_files);
2150
5956
    of = av_mallocz(sizeof(*of));
2151
5956
    if (!of)
2152
        exit_program(1);
2153
5956
    output_files[nb_output_files - 1] = of;
2154
2155
5956
    of->ost_index      = nb_output_streams;
2156
5956
    of->recording_time = o->recording_time;
2157
5956
    of->start_time     = o->start_time;
2158
5956
    of->limit_filesize = o->limit_filesize;
2159
5956
    of->shortest       = o->shortest;
2160
5956
    av_dict_copy(&of->opts, o->g->format_opts, 0);
2161
2162
5956
    if (!strcmp(filename, "-"))
2163
2205
        filename = "pipe:";
2164
2165
5956
    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2166
5956
    if (!oc) {
2167
        print_error(filename, err);
2168
        exit_program(1);
2169
    }
2170
2171
5956
    of->ctx = oc;
2172
5956
    if (o->recording_time != INT64_MAX)
2173
129
        oc->duration = o->recording_time;
2174
2175
5956
    oc->interrupt_callback = int_cb;
2176
2177
5956
    e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2178
5956
    if (e) {
2179
3401
        const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2180
3401
        av_opt_eval_flags(oc, o, e->value, &format_flags);
2181
    }
2182
5956
    if (o->bitexact) {
2183
1630
        format_flags |= AVFMT_FLAG_BITEXACT;
2184
1630
        oc->flags    |= AVFMT_FLAG_BITEXACT;
2185
    }
2186
2187
    /* create streams for all unlabeled output pads */
2188
6036
    for (i = 0; i < nb_filtergraphs; i++) {
2189
80
        FilterGraph *fg = filtergraphs[i];
2190
163
        for (j = 0; j < fg->nb_outputs; j++) {
2191
83
            OutputFilter *ofilter = fg->outputs[j];
2192
2193

83
            if (!ofilter->out_tmp || ofilter->out_tmp->name)
2194
4
                continue;
2195
2196

79
            switch (ofilter->type) {
2197
65
            case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2198
14
            case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2199
            case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2200
            }
2201
79
            init_output_filter(ofilter, o, oc);
2202
        }
2203
    }
2204
2205
5956
    if (!o->nb_stream_maps) {
2206
5902
        char *subtitle_codec_name = NULL;
2207
        /* pick the "best" stream of each type */
2208
2209
        /* video: highest resolution */
2210

5902
        if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2211
4986
            int area = 0, idx = -1;
2212
4986
            int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2213
10251
            for (i = 0; i < nb_input_streams; i++) {
2214
                int new_area;
2215
5265
                ist = input_streams[i];
2216
5265
                new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2217
5265
                           + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2218
5265
                if (ist->user_set_discard == AVDISCARD_ALL)
2219
                    continue;
2220

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

5265
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2223
                    new_area > area) {
2224

4742
                    if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2225
                        continue;
2226
4742
                    area = new_area;
2227
4742
                    idx = i;
2228
                }
2229
            }
2230
4986
            if (idx >= 0)
2231
4742
                new_video_stream(o, oc, idx);
2232
        }
2233
2234
        /* audio: most channels */
2235

5902
        if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2236
5010
            int best_score = 0, idx = -1;
2237
10193
            for (i = 0; i < nb_input_streams; i++) {
2238
                int score;
2239
5183
                ist = input_streams[i];
2240
5183
                score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2241
5183
                        + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2242
5183
                if (ist->user_set_discard == AVDISCARD_ALL)
2243
                    continue;
2244

5183
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2245
                    score > best_score) {
2246
1162
                    best_score = score;
2247
1162
                    idx = i;
2248
                }
2249
            }
2250
5010
            if (idx >= 0)
2251
1162
                new_audio_stream(o, oc, idx);
2252
        }
2253
2254
        /* subtitles: pick first */
2255

9350
        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2256

5902
        if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2257
58
            for (i = 0; i < nb_input_streams; i++)
2258
49
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2259
                    AVCodecDescriptor const *input_descriptor =
2260
35
                        avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2261
35
                    AVCodecDescriptor const *output_descriptor = NULL;
2262
                    AVCodec const *output_codec =
2263
35
                        avcodec_find_encoder(oc->oformat->subtitle_codec);
2264
35
                    int input_props = 0, output_props = 0;
2265
35
                    if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2266
                        continue;
2267
35
                    if (output_codec)
2268
33
                        output_descriptor = avcodec_descriptor_get(output_codec->id);
2269
35
                    if (input_descriptor)
2270
35
                        input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2271
35
                    if (output_descriptor)
2272
33
                        output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2273
35
                    if (subtitle_codec_name ||
2274

28
                        input_props & output_props ||
2275
                        // Map dvb teletext which has neither property to any output subtitle encoder
2276
                        input_descriptor && output_descriptor &&
2277
                        (!input_descriptor->props ||
2278
                         !output_descriptor->props)) {
2279
35
                        new_subtitle_stream(o, oc, i);
2280
35
                        break;
2281
                    }
2282
                }
2283
        }
2284
        /* Data only if codec id match */
2285
5902
        if (!o->data_disable ) {
2286
5902
            enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2287

5902
            for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2288
                if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2289
                    continue;
2290
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2291
                    && input_streams[i]->st->codecpar->codec_id == codec_id )
2292
                    new_data_stream(o, oc, i);
2293
            }
2294
        }
2295
    } else {
2296
138
        for (i = 0; i < o->nb_stream_maps; i++) {
2297
84
            StreamMap *map = &o->stream_maps[i];
2298
2299
84
            if (map->disabled)
2300
                continue;
2301
2302
84
            if (map->linklabel) {
2303
                FilterGraph *fg;
2304
3
                OutputFilter *ofilter = NULL;
2305
                int j, k;
2306
2307
3
                for (j = 0; j < nb_filtergraphs; j++) {
2308
3
                    fg = filtergraphs[j];
2309
3
                    for (k = 0; k < fg->nb_outputs; k++) {
2310
3
                        AVFilterInOut *out = fg->outputs[k]->out_tmp;
2311

3
                        if (out && !strcmp(out->name, map->linklabel)) {
2312
3
                            ofilter = fg->outputs[k];
2313
3
                            goto loop_end;
2314
                        }
2315
                    }
2316
                }
2317
loop_end:
2318
3
                if (!ofilter) {
2319
                    av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2320
                           "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2321
                    exit_program(1);
2322
                }
2323
3
                init_output_filter(ofilter, o, oc);
2324
            } else {
2325
81
                int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2326
2327
81
                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2328
81
                if (ist->user_set_discard == AVDISCARD_ALL) {
2329
                    av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2330
                           map->file_index, map->stream_index);
2331
                    exit_program(1);
2332
                }
2333

81
                if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2334
                    continue;
2335

81
                if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2336
                    continue;
2337

81
                if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2338
                    continue;
2339

81
                if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2340
                    continue;
2341
2342
81
                ost = NULL;
2343

81
                switch (ist->st->codecpar->codec_type) {
2344
23
                case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2345
46
                case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2346
2
                case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2347
10
                case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2348
                case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2349
                case AVMEDIA_TYPE_UNKNOWN:
2350
                    if (copy_unknown_streams) {
2351
                        ost = new_unknown_stream   (o, oc, src_idx);
2352
                        break;
2353
                    }
2354
                default:
2355
                    av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2356
                           "Cannot map stream #%d:%d - unsupported type.\n",
2357
                           map->file_index, map->stream_index);
2358
                    if (!ignore_unknown_streams) {
2359
                        av_log(NULL, AV_LOG_FATAL,
2360
                               "If you want unsupported types ignored instead "
2361
                               "of failing, please use the -ignore_unknown option\n"
2362
                               "If you want them copied, please use -copy_unknown\n");
2363
                        exit_program(1);
2364
                    }
2365
                }
2366
81
                if (ost)
2367
81
                    ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2368
81
                                                  + map->sync_stream_index];
2369
            }
2370
        }
2371
    }
2372
2373
    /* handle attached files */
2374
5957
    for (i = 0; i < o->nb_attachments; i++) {
2375
        AVIOContext *pb;
2376
        uint8_t *attachment;
2377
        const char *p;
2378
        int64_t len;
2379
2380
1
        if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2381
            av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2382
                   o->attachments[i]);
2383
            exit_program(1);
2384
        }
2385
1
        if ((len = avio_size(pb)) <= 0) {
2386
            av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2387
                   o->attachments[i]);
2388
            exit_program(1);
2389
        }
2390

2
        if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2391
1
            !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2392
            av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2393
                   o->attachments[i]);
2394
            exit_program(1);
2395
        }
2396
1
        avio_read(pb, attachment, len);
2397
1
        memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2398
2399
1
        ost = new_attachment_stream(o, oc, -1);
2400
1
        ost->stream_copy               = 0;
2401
1
        ost->attachment_filename       = o->attachments[i];
2402
1
        ost->st->codecpar->extradata      = attachment;
2403
1
        ost->st->codecpar->extradata_size = len;
2404
2405
1
        p = strrchr(o->attachments[i], '/');
2406

1
        av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2407
1
        avio_closep(&pb);
2408
    }
2409
2410
#if FF_API_LAVF_AVCTX
2411
12059
    for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2412
        AVDictionaryEntry *e;
2413
6103
        ost = output_streams[i];
2414
2415

6103
        if ((ost->stream_copy || ost->attachment_filename)
2416
298
            && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2417

67
            && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2418
67
            if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2419
                exit_program(1);
2420
    }
2421
#endif
2422
2423

5956
    if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2424
        av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2425
        av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2426
        exit_program(1);
2427
    }
2428
2429
    /* check if all codec options have been used */
2430
5956
    unused_opts = strip_specifiers(o->g->codec_opts);
2431
12059
    for (i = of->ost_index; i < nb_output_streams; i++) {
2432
6103
        e = NULL;
2433
20088
        while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2434
                                AV_DICT_IGNORE_SUFFIX)))
2435
13985
            av_dict_set(&unused_opts, e->key, NULL, 0);
2436
    }
2437
2438
5956
    e = NULL;
2439
6210
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2440
254
        const AVClass *class = avcodec_get_class();
2441
254
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2442
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2443
254
        const AVClass *fclass = avformat_get_class();
2444
254
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2445
                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2446

254
        if (!option || foption)
2447
9
            continue;
2448
2449
2450
253
        if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2451
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2452
                   "output file #%d (%s) is not an encoding option.\n", e->key,
2453
                   option->help ? option->help : "", nb_output_files - 1,
2454
                   filename);
2455
            exit_program(1);
2456
        }
2457
2458
        // gop_timecode is injected by generic code but not always used
2459
253
        if (!strcmp(e->key, "gop_timecode"))
2460
8
            continue;
2461
2462
245
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2463
               "output file #%d (%s) has not been used for any stream. The most "
2464
               "likely reason is either wrong type (e.g. a video option with "
2465
               "no video streams) or that it is a private option of some encoder "
2466
               "which was not actually used for any stream.\n", e->key,
2467
245
               option->help ? option->help : "", nb_output_files - 1, filename);
2468
    }
2469
5956
    av_dict_free(&unused_opts);
2470
2471
    /* set the decoding_needed flags and create simple filtergraphs */
2472
12059
    for (i = of->ost_index; i < nb_output_streams; i++) {
2473
6103
        OutputStream *ost = output_streams[i];
2474
2475

6103
        if (ost->encoding_needed && ost->source_index >= 0) {
2476
5723
            InputStream *ist = input_streams[ost->source_index];
2477
5723
            ist->decoding_needed |= DECODING_FOR_OST;
2478
2479
5723
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2480
1129
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2481
5693
                err = init_simple_filtergraph(ist, ost);
2482
5693
                if (err < 0) {
2483
                    av_log(NULL, AV_LOG_ERROR,
2484
                           "Error initializing a simple filtergraph between streams "
2485
                           "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2486
                           nb_output_files - 1, ost->st->index);
2487
                    exit_program(1);
2488
                }
2489
            }
2490
        }
2491
2492
        /* set the filter output constraints */
2493
6103
        if (ost->filter) {
2494
5775
            OutputFilter *f = ost->filter;
2495
            int count;
2496
5775
            switch (ost->enc_ctx->codec_type) {
2497
4661
            case AVMEDIA_TYPE_VIDEO:
2498
4661
                f->frame_rate = ost->frame_rate;
2499
4661
                f->width      = ost->enc_ctx->width;
2500
4661
                f->height     = ost->enc_ctx->height;
2501
4661
                if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2502
3356
                    f->format = ost->enc_ctx->pix_fmt;
2503
1305
                } else if (ost->enc->pix_fmts) {
2504
290
                    count = 0;
2505
1474
                    while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2506
1184
                        count++;
2507
290
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2508
290
                    if (!f->formats)
2509
                        exit_program(1);
2510
290
                    memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2511
                }
2512
4661
                break;
2513
1114
            case AVMEDIA_TYPE_AUDIO:
2514
1114
                if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2515
                    f->format = ost->enc_ctx->sample_fmt;
2516
1114
                } else if (ost->enc->sample_fmts) {
2517
1114
                    count = 0;
2518
2265
                    while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2519
1151
                        count++;
2520
1114
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2521
1114
                    if (!f->formats)
2522
                        exit_program(1);
2523
1114
                    memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2524
                }
2525
1114
                if (ost->enc_ctx->sample_rate) {
2526
25
                    f->sample_rate = ost->enc_ctx->sample_rate;
2527
1089
                } else if (ost->enc->supported_samplerates) {
2528
35
                    count = 0;
2529
305
                    while (ost->enc->supported_samplerates[count])
2530
270
                        count++;
2531
35
                    f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2532
35
                    if (!f->sample_rates)
2533
                        exit_program(1);
2534
35
                    memcpy(f->sample_rates, ost->enc->supported_samplerates,
2535
35
                           (count + 1) * sizeof(*f->sample_rates));
2536
                }
2537
1114
                if (ost->enc_ctx->channels) {
2538
12
                    f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2539
1102
                } else if (ost->enc->channel_layouts) {
2540
42
                    count = 0;
2541
280
                    while (ost->enc->channel_layouts[count])
2542
238
                        count++;
2543
42
                    f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2544
42
                    if (!f->channel_layouts)
2545
                        exit_program(1);
2546
42
                    memcpy(f->channel_layouts, ost->enc->channel_layouts,
2547
42
                           (count + 1) * sizeof(*f->channel_layouts));
2548
                }
2549
1114
                break;
2550
            }
2551
6103
        }
2552
    }
2553
2554
    /* check filename in case of an image number is expected */
2555
5956
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2556
        if (!av_filename_number_test(oc->url)) {
2557
            print_error(oc->url, AVERROR(EINVAL));
2558
            exit_program(1);
2559
        }
2560
    }
2561
2562

5956
    if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2563
        av_log(NULL, AV_LOG_ERROR,
2564
               "No input streams but output needs an input stream\n");
2565
        exit_program(1);
2566
    }
2567
2568
5956
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2569
        /* test if it already exists to avoid losing precious files */
2570
5902
        assert_file_overwrite(filename);
2571
2572
        /* open the file */
2573
5902
        if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2574
5902
                              &oc->interrupt_callback,
2575
                              &of->opts)) < 0) {
2576
            print_error(filename, err);
2577
            exit_program(1);
2578
        }
2579

54
    } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2580
        assert_file_overwrite(filename);
2581
2582
5956
    if (o->mux_preload) {
2583
        av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2584
    }
2585
5956
    oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2586
2587
    /* copy metadata */
2588
5961
    for (i = 0; i < o->nb_metadata_map; i++) {
2589
        char *p;
2590
5
        int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2591
2592
5
        if (in_file_index >= nb_input_files) {
2593
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2594
            exit_program(1);
2595
        }
2596

8
        copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2597
                      in_file_index >= 0 ?
2598
3
                      input_files[in_file_index]->ctx : NULL, o);
2599
    }
2600
2601
    /* copy chapters */
2602
5956
    if (o->chapters_input_file >= nb_input_files) {
2603
5956
        if (o->chapters_input_file == INT_MAX) {
2604
            /* copy chapters from the first input file that has them*/
2605
5956
            o->chapters_input_file = -1;
2606
11929
            for (i = 0; i < nb_input_files; i++)
2607
5985
                if (input_files[i]->ctx->nb_chapters) {
2608
12
                    o->chapters_input_file = i;
2609
12
                    break;
2610
                }
2611
        } else {
2612
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2613
                   o->chapters_input_file);
2614
            exit_program(1);
2615
        }
2616
    }
2617
5956
    if (o->chapters_input_file >= 0)
2618
12
        copy_chapters(input_files[o->chapters_input_file], of,
2619
12
                      !o->metadata_chapters_manual);
2620
2621
    /* copy global metadata by default */
2622

5956
    if (!o->metadata_global_manual && nb_input_files){
2623
5913
        av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2624
                     AV_DICT_DONT_OVERWRITE);
2625
5913
        if(o->recording_time != INT64_MAX)
2626
123
            av_dict_set(&oc->metadata, "duration", NULL, 0);
2627
5913
        av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2628
    }
2629
5956
    if (!o->metadata_streams_manual)
2630
12055
        for (i = of->ost_index; i < nb_output_streams; i++) {
2631
            InputStream *ist;
2632
6100
            if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2633
83
                continue;
2634
6017
            ist = input_streams[output_streams[i]->source_index];
2635
6017
            av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2636
6017
            if (!output_streams[i]->stream_copy) {
2637
5720
                av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2638
            }
2639
        }
2640
2641
    /* process manually set programs */
2642
5956
    for (i = 0; i < o->nb_program; i++) {
2643
        const char *p = o->program[i].u.str;
2644
        int progid = i+1;
2645
        AVProgram *program;
2646
2647
        while(*p) {
2648
            const char *p2 = av_get_token(&p, ":");
2649
            const char *to_dealloc = p2;
2650
            char *key;
2651
            if (!p2)
2652
                break;
2653
2654
            if(*p) p++;
2655
2656
            key = av_get_token(&p2, "=");
2657
            if (!key || !*p2) {
2658
                av_freep(&to_dealloc);
2659
                av_freep(&key);
2660
                break;
2661
            }
2662
            p2++;
2663
2664
            if (!strcmp(key, "program_num"))
2665
                progid = strtol(p2, NULL, 0);
2666
            av_freep(&to_dealloc);
2667
            av_freep(&key);
2668
        }
2669
2670
        program = av_new_program(oc, progid);
2671
2672
        p = o->program[i].u.str;
2673
        while(*p) {
2674
            const char *p2 = av_get_token(&p, ":");
2675
            const char *to_dealloc = p2;
2676
            char *key;
2677
            if (!p2)
2678
                break;
2679
            if(*p) p++;
2680
2681
            key = av_get_token(&p2, "=");
2682
            if (!key) {
2683
                av_log(NULL, AV_LOG_FATAL,
2684
                       "No '=' character in program string %s.\n",
2685
                       p2);
2686
                exit_program(1);
2687
            }
2688
            if (!*p2)
2689
                exit_program(1);
2690
            p2++;
2691
2692
            if (!strcmp(key, "title")) {
2693
                av_dict_set(&program->metadata, "title", p2, 0);
2694
            } else if (!strcmp(key, "program_num")) {
2695
            } else if (!strcmp(key, "st")) {
2696
                int st_num = strtol(p2, NULL, 0);
2697
                av_program_add_stream_index(oc, progid, st_num);
2698
            } else {
2699
                av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2700
                exit_program(1);
2701
            }
2702
            av_freep(&to_dealloc);
2703
            av_freep(&key);
2704
        }
2705
    }
2706
2707
    /* process manually set metadata */
2708
6098
    for (i = 0; i < o->nb_metadata; i++) {
2709
        AVDictionary **m;
2710
        char type, *val;
2711
        const char *stream_spec;
2712
142
        int index = 0, j, ret = 0;
2713
2714
142
        val = strchr(o->metadata[i].u.str, '=');
2715
142
        if (!val) {
2716
            av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2717
                   o->metadata[i].u.str);
2718
            exit_program(1);
2719
        }
2720
142
        *val++ = 0;
2721
2722
142
        parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2723
142
        if (type == 's') {
2724
19
            for (j = 0; j < oc->nb_streams; j++) {
2725
11
                ost = output_streams[nb_output_streams - oc->nb_streams + j];
2726
11
                if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2727
8
                    if (!strcmp(o->metadata[i].u.str, "rotate")) {
2728
                        char *tail;
2729
1
                        double theta = av_strtod(val, &tail);
2730
1
                        if (!*tail) {
2731
1
                            ost->rotate_overridden = 1;
2732
1
                            ost->rotate_override_value = theta;
2733
                        }
2734
                    } else {
2735
7
                        av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2736
                    }
2737
3
                } else if (ret < 0)
2738
                    exit_program(1);
2739
            }
2740
        }
2741
        else {
2742

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