GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg_opt.c Lines: 1131 1960 57.7 %
Date: 2020-09-28 00:47:38 Branches: 900 2376 37.9 %

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
int auto_conversion_filters = 1;
176
177
178
static int intra_only         = 0;
179
static int file_overwrite     = 0;
180
static int no_file_overwrite  = 0;
181
static int do_psnr            = 0;
182
static int input_sync;
183
static int input_stream_potentially_available = 0;
184
static int ignore_unknown_streams = 0;
185
static int copy_unknown_streams = 0;
186
static int find_stream_info = 1;
187
188
11970
static void uninit_options(OptionsContext *o)
189
{
190
11970
    const OptionDef *po = options;
191
    int i;
192
193
    /* all OPT_SPEC and OPT_STRING can be freed in generic way */
194
2154600
    while (po->name) {
195
2142630
        void *dst = (uint8_t*)o + po->u.off;
196
197
2142630
        if (po->flags & OPT_SPEC) {
198
562590
            SpecifierOpt **so = dst;
199
562590
            int i, *count = (int*)(so + 1);
200
587016
            for (i = 0; i < *count; i++) {
201
24426
                av_freep(&(*so)[i].specifier);
202
24426
                if (po->flags & OPT_STRING)
203
19781
                    av_freep(&(*so)[i].u.str);
204
            }
205
562590
            av_freep(so);
206
562590
            *count = 0;
207

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

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

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

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

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

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

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

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

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

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

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

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

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

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



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



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

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





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





6328
        MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
799
800
6328
        ist->autorotate = 1;
801





6328
        MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
802
803





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





6328
        MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
816
817





6328
        MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
818
6328
        ist->user_set_discard = AVDISCARD_NONE;
819
820

6328
        if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
821

6328
            (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
822

6328
            (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
823

6328
            (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
824
                ist->user_set_discard = AVDISCARD_ALL;
825
826

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

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





4884
            MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
867

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





4860
            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
876
877





9479
            MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
878





4860
            MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
879
                                 hwaccel_output_format, ic, st);
880
881

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

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





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





1377
            MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
952
1373
            guess_input_channel_layout(ist);
953
1373
            break;
954
94
        case AVMEDIA_TYPE_DATA:
955
        case AVMEDIA_TYPE_SUBTITLE: {
956
94
            char *canvas_size = NULL;
957
94
            if(!ist->dec)
958
48
                ist->dec = avcodec_find_decoder(par->codec_id);
959





94
            MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
960





94
            MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
961

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

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

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

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

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

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

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

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

8371
    MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
1137

8371
    MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
1138

8371
    MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1139

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

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

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

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

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

6118
    if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1383





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





5820
        MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1468
5820
        ost->autoscale = 1;
1469





5820
        MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1470

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





6119
    MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1502
6118
    if (time_base) {
1503
        AVRational q;
1504
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1505

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





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





18002
    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1525
10384
    for (i = 0; i<o->nb_max_frames; i++) {
1526
4272
        char *p = o->max_frames[i].specifier;
1527

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





6118
    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1535
1536





6203
    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1537

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





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





6404
    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1555
6118
    if (qscale >= 0) {
1556
232
        ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1557
232
        ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1558
    }
1559
1560





6118
    MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1561
6118
    ost->disposition = av_strdup(ost->disposition);
1562
1563
6118
    ost->max_muxing_queue_size = 128;
1564





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

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

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

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





4863
    MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1685

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

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





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





4845
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1704





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





5286
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1716

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





8036
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1723

4671
        if (frame_pix_fmt && *frame_pix_fmt == '+') {
1724
            ost->keep_pix_fmt = 1;
1725
            if (!*++frame_pix_fmt)
1726
                frame_pix_fmt = NULL;
1727
        }
1728

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





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





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





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





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





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





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





4672
        MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1849
4671
        if (ost->forced_keyframes)
1850
1
            ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1851
1852





4671
        MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1853
1854
4671
        ost->top_field_first = -1;
1855





4674
        MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1856
1857
1858
4671
        ost->avfilter = get_ost_filters(o, oc, ost);
1859
4671
        if (!ost->avfilter)
1860
            exit_program(1);
1861
    } else {
1862





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





1228
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1885





1794
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1886
1887
1227
    if (!ost->stream_copy) {
1888
1118
        char *sample_fmt = NULL;
1889
1890





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





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





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





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

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

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

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





38
    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1991
1992
38
    if (!ost->stream_copy) {
1993
31
        char *frame_size = NULL;
1994
1995





31
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1996

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

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

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

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

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

83
            if (!ofilter->out_tmp || ofilter->out_tmp->name)
2196
4
                continue;
2197
2198

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

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

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

5275
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2225
                    new_area > area) {
2226

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

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

5197
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2247
                    score > best_score) {
2248
1166
                    best_score = score;
2249
1166
                    idx = i;
2250
                }
2251
            }
2252
5024
            if (idx >= 0)
2253
1166
                new_audio_stream(o, oc, idx);
2254
        }
2255
2256
        /* subtitles: pick first */
2257

9368
        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2258

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

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

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

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

82
                if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2336
                    continue;
2337

82
                if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2338
                    continue;
2339

82
                if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2340
                    continue;
2341

82
                if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2342
                    continue;
2343
2344
82
                ost = NULL;
2345

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

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

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

6118
        if ((ost->stream_copy || ost->attachment_filename)
2418
298
            && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2419

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

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

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

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

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

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

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

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

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