GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg_opt.c Lines: 1129 1966 57.4 %
Date: 2021-01-26 11:44:58 Branches: 899 2396 37.5 %

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

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

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

10
    if ((n == 1 || n == 3) && m->channel_idx == -1) {
490
1
        m->file_idx = m->stream_idx = -1;
491
1
        if (n == 1)
492
1
            m->ofile_idx = m->ostream_idx = -1;
493
1
        av_free(mapchan);
494
1
        return 0;
495
    }
496
497
    /* normal syntax */
498
9
    n = sscanf(arg, "%d.%d.%d:%d.%d",
499
               &m->file_idx,  &m->stream_idx, &m->channel_idx,
500
               &m->ofile_idx, &m->ostream_idx);
501
502

9
    if (n != 3 && n != 5) {
503
        av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
504
               "[file.stream.channel|-1][:syncfile:syncstream]\n");
505
        exit_program(1);
506
    }
507
508
9
    if (n != 5) // only file.stream.channel specified
509
9
        m->ofile_idx = m->ostream_idx = -1;
510
511
    /* check input */
512

9
    if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
513
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
514
               m->file_idx);
515
        exit_program(1);
516
    }
517
9
    if (m->stream_idx < 0 ||
518
9
        m->stream_idx >= input_files[m->file_idx]->nb_streams) {
519
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
520
               m->file_idx, m->stream_idx);
521
        exit_program(1);
522
    }
523
9
    st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
524
9
    if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
525
        av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
526
               m->file_idx, m->stream_idx);
527
        exit_program(1);
528
    }
529
    /* allow trailing ? to map_channel */
530
9
    if (allow_unused = strchr(mapchan, '?'))
531
2
        *allow_unused = 0;
532

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

29
        switch (*arg) {
612
17
        case 'g':
613
17
            break;
614
12
        case 's':
615

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

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

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

2
        if (type_out == 'c' || !*outspec)
652
            o->metadata_chapters_manual = 1;
653
2
        return 0;
654
    }
655
656

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

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

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



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



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

10481
    if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
750
1
        codec = encoder ? avcodec_find_encoder(desc->id) :
751
                          avcodec_find_decoder(desc->id);
752
1
        if (codec)
753
1
            av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
754
                   codec_string, codec->name, desc->name);
755
    }
756
757
10481
    if (!codec) {
758
        av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
759
        exit_program(1);
760
    }
761
10481
    if (codec->type != type) {
762
        av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
763
        exit_program(1);
764
    }
765
10481
    return codec;
766
}
767
768
12580
static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
769
{
770
12580
    char *codec_name = NULL;
771
772





17466
    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
773
12580
    if (codec_name) {
774
4880
        AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
775
4880
        st->codecpar->codec_id = codec->id;
776
4880
        return codec;
777
    } else
778
7700
        return avcodec_find_decoder(st->codecpar->codec_id);
779
}
780
781
/* Add all the streams from the given input file to the global
782
 * list of input streams. */
783
6008
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
784
{
785
    int i, ret;
786
787
12345
    for (i = 0; i < ic->nb_streams; i++) {
788
6337
        AVStream *st = ic->streams[i];
789
6337
        AVCodecParameters *par = st->codecpar;
790
6337
        InputStream *ist = av_mallocz(sizeof(*ist));
791
6337
        char *framerate = NULL, *hwaccel_device = NULL;
792
6337
        const char *hwaccel = NULL;
793
6337
        char *hwaccel_output_format = NULL;
794
6337
        char *codec_tag = NULL;
795
        char *next;
796
6337
        char *discard_str = NULL;
797
6337
        const AVClass *cc = avcodec_get_class();
798
6337
        const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
799
800
6337
        if (!ist)
801
            exit_program(1);
802
803
6337
        GROW_ARRAY(input_streams, nb_input_streams);
804
6337
        input_streams[nb_input_streams - 1] = ist;
805
806
6337
        ist->st = st;
807
6337
        ist->file_index = nb_input_files;
808
6337
        ist->discard = 1;
809
6337
        st->discard  = AVDISCARD_ALL;
810
6337
        ist->nb_samples = 0;
811
6337
        ist->min_pts = INT64_MAX;
812
6337
        ist->max_pts = INT64_MIN;
813
814
6337
        ist->ts_scale = 1.0;
815





6337
        MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
816
817
6337
        ist->autorotate = 1;
818





6337
        MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
819
820





6339
        MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
821
6337
        if (codec_tag) {
822
2
            uint32_t tag = strtol(codec_tag, &next, 0);
823
2
            if (*next)
824
2
                tag = AV_RL32(codec_tag);
825
2
            st->codecpar->codec_tag = tag;
826
        }
827
828
6337
        ist->dec = choose_decoder(o, ic, st);
829
6337
        ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
830
831
6337
        ist->reinit_filters = -1;
832





6337
        MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
833
834





6337
        MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
835
6337
        ist->user_set_discard = AVDISCARD_NONE;
836
837

6337
        if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
838

6337
            (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
839

6337
            (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
840

6337
            (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
841
                ist->user_set_discard = AVDISCARD_ALL;
842
843

6337
        if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
844
            av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
845
                    discard_str);
846
            exit_program(1);
847
        }
848
849
6337
        ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
850
851
6337
        ist->dec_ctx = avcodec_alloc_context3(ist->dec);
852
6337
        if (!ist->dec_ctx) {
853
            av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
854
            exit_program(1);
855
        }
856
857
6337
        ret = avcodec_parameters_to_context(ist->dec_ctx, par);
858
6337
        if (ret < 0) {
859
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
860
            exit_program(1);
861
        }
862
863
6337
        if (o->bitexact)
864
84
            ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
865
866

6337
        switch (par->codec_type) {
867
4863
        case AVMEDIA_TYPE_VIDEO:
868
4863
            if(!ist->dec)
869
                ist->dec = avcodec_find_decoder(par->codec_id);
870
871
            // avformat_find_stream_info() doesn't set this for us anymore.
872
4863
            ist->dec_ctx->framerate = st->avg_frame_rate;
873
874





4887
            MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
875

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





4863
            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
884
885





9485
            MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
886





4863
            MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
887
                                 hwaccel_output_format, ic, st);
888
889

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

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





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





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





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





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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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





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





5829
        MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1476
5829
        ost->autoscale = 1;
1477





5829
        MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1478

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





6129
    MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1510
6128
    if (time_base) {
1511
        AVRational q;
1512
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1513

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





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





18012
    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1533
10394
    for (i = 0; i<o->nb_max_frames; i++) {
1534
4272
        char *p = o->max_frames[i].specifier;
1535

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





6128
    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1543
1544





6213
    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1545

6128
    if (bsfs && *bsfs) {
1546
85
        ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1547
85
        if (ret < 0) {
1548
            av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1549
            exit_program(1);
1550
        }
1551
    }
1552
1553





6134
    MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1554
6128
    if (codec_tag) {
1555
6
        uint32_t tag = strtol(codec_tag, &next, 0);
1556
6
        if (*next)
1557
6
            tag = AV_RL32(codec_tag);
1558
6
        ost->st->codecpar->codec_tag =
1559
6
        ost->enc_ctx->codec_tag = tag;
1560
    }
1561
1562





6414
    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1563
6128
    if (qscale >= 0) {
1564
232
        ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1565
232
        ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1566
    }
1567
1568





6128
    MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1569
6128
    ost->disposition = av_strdup(ost->disposition);
1570
1571
6128
    ost->max_muxing_queue_size = 128;
1572





6130
    MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1573
6128
    ost->max_muxing_queue_size *= sizeof(AVPacket);
1574
1575
6128
    ost->muxing_queue_data_size = 0;
1576
1577
6128
    ost->muxing_queue_data_threshold = 50*1024*1024;
1578





6128
    MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st);
1579
1580
6128
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1581
2343
        ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1582
1583
6128
    av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1584
1585
6128
    av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1586

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

5798
    if (ost->filters_script && ost->filters) {
1658
        av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1659
               "output stream #%d:%d.\n", nb_output_files, st->index);
1660
        exit_program(1);
1661
    }
1662
1663
5798
    if (ost->filters_script)
1664
4
        return read_file(ost->filters_script);
1665
5794
    else if (ost->filters)
1666
3072
        return av_strdup(ost->filters);
1667
1668
2722
    return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1669
                     "null" : "anull");
1670
}
1671
1672
281
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1673
                                     const OutputStream *ost, enum AVMediaType type)
1674
{
1675

281
    if (ost->filters_script || ost->filters) {
1676
        av_log(NULL, AV_LOG_ERROR,
1677
               "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1678
               "Filtering and streamcopy cannot be used together.\n",
1679
               ost->filters ? "Filtergraph" : "Filtergraph script",
1680
               ost->filters ? ost->filters : ost->filters_script,
1681
               av_get_media_type_string(type), ost->file_index, ost->index);
1682
        exit_program(1);
1683
    }
1684
281
}
1685
1686
4846
static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1687
{
1688
    AVStream *st;
1689
    OutputStream *ost;
1690
    AVCodecContext *video_enc;
1691
4846
    char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1692
1693
4846
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1694
4846
    st  = ost->st;
1695
4846
    video_enc = ost->enc_ctx;
1696
1697





4867
    MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1698

4846
    if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1699
        av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1700
        exit_program(1);
1701
    }
1702

4846
    if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1703
        av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1704
1705





4846
    MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1706
4846
    if (frame_aspect_ratio) {
1707
        AVRational q;
1708
        if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1709
            q.num <= 0 || q.den <= 0) {
1710
            av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1711
            exit_program(1);
1712
        }
1713
        ost->frame_aspect_ratio = q;
1714
    }
1715
1716





4849
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1717





7397
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1718
1719
4846
    if (!ost->stream_copy) {
1720
4675
        const char *p = NULL;
1721
4675
        char *frame_size = NULL;
1722
4675
        char *frame_pix_fmt = NULL;
1723
4675
        char *intra_matrix = NULL, *inter_matrix = NULL;
1724
4675
        char *chroma_intra_matrix = NULL;
1725
4675
        int do_pass = 0;
1726
        int i;
1727
1728





5290
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1729

4675
        if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1730
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1731
            exit_program(1);
1732
        }
1733
1734
4675
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1735





8040
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1736

4675
        if (frame_pix_fmt && *frame_pix_fmt == '+') {
1737
            ost->keep_pix_fmt = 1;
1738
            if (!*++frame_pix_fmt)
1739
                frame_pix_fmt = NULL;
1740
        }
1741

4675
        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1742
            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1743
            exit_program(1);
1744
        }
1745
4675
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1746
1747
4675
        if (intra_only)
1748
            video_enc->gop_size = 0;
1749





4675
        MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1750
4675
        if (intra_matrix) {
1751
            if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1752
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1753
                exit_program(1);
1754
            }
1755
            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1756
        }
1757





4675
        MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1758
4675
        if (chroma_intra_matrix) {
1759
            uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1760
            if (!p) {
1761
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1762
                exit_program(1);
1763
            }
1764
            video_enc->chroma_intra_matrix = p;
1765
            parse_matrix_coeffs(p, chroma_intra_matrix);
1766
        }
1767





4675
        MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1768
4675
        if (inter_matrix) {
1769
            if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1770
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1771
                exit_program(1);
1772
            }
1773
            parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1774
        }
1775
1776





4675
        MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1777
4675
        for (i = 0; p; i++) {
1778
            int start, end, q;
1779
            int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1780
            if (e != 3) {
1781
                av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1782
                exit_program(1);
1783
            }
1784
            video_enc->rc_override =
1785
                av_realloc_array(video_enc->rc_override,
1786
                                 i + 1, sizeof(RcOverride));
1787
            if (!video_enc->rc_override) {
1788
                av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1789
                exit_program(1);
1790
            }
1791
            video_enc->rc_override[i].start_frame = start;
1792
            video_enc->rc_override[i].end_frame   = end;
1793
            if (q > 0) {
1794
                video_enc->rc_override[i].qscale         = q;
1795
                video_enc->rc_override[i].quality_factor = 1.0;
1796
            }
1797
            else {
1798
                video_enc->rc_override[i].qscale         = 0;
1799
                video_enc->rc_override[i].quality_factor = -q/100.0;
1800
            }
1801
            p = strchr(p, '/');
1802
            if (p) p++;
1803
        }
1804
4675
        video_enc->rc_override_count = i;
1805
1806
4675
        if (do_psnr)
1807
            video_enc->flags|= AV_CODEC_FLAG_PSNR;
1808
1809
        /* two pass mode */
1810





4675
        MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1811
4675
        if (do_pass) {
1812
            if (do_pass & 1) {
1813
                video_enc->flags |= AV_CODEC_FLAG_PASS1;
1814
                av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1815
            }
1816
            if (do_pass & 2) {
1817
                video_enc->flags |= AV_CODEC_FLAG_PASS2;
1818
                av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1819
            }
1820
        }
1821
1822





4675
        MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1823
4675
        if (ost->logfile_prefix &&
1824
            !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1825
            exit_program(1);
1826
1827
4675
        if (do_pass) {
1828
            char logfilename[1024];
1829
            FILE *f;
1830
1831
            snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1832
                     ost->logfile_prefix ? ost->logfile_prefix :
1833
                                           DEFAULT_PASS_LOGFILENAME_PREFIX,
1834
                     i);
1835
            if (!strcmp(ost->enc->name, "libx264")) {
1836
                av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1837
            } else {
1838
                if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1839
                    char  *logbuffer = read_file(logfilename);
1840
1841
                    if (!logbuffer) {
1842
                        av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1843
                               logfilename);
1844
                        exit_program(1);
1845
                    }
1846
                    video_enc->stats_in = logbuffer;
1847
                }
1848
                if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1849
                    f = av_fopen_utf8(logfilename, "wb");
1850
                    if (!f) {
1851
                        av_log(NULL, AV_LOG_FATAL,
1852
                               "Cannot write log file '%s' for pass-1 encoding: %s\n",
1853
                               logfilename, strerror(errno));
1854
                        exit_program(1);
1855
                    }
1856
                    ost->logfile = f;
1857
                }
1858
            }
1859
        }
1860
1861





4676
        MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1862
4675
        if (ost->forced_keyframes)
1863
1
            ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1864
1865





4675
        MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1866
1867
4675
        ost->top_field_first = -1;
1868





4678
        MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1869
1870
1871
4675
        ost->avfilter = get_ost_filters(o, oc, ost);
1872
4675
        if (!ost->avfilter)
1873
            exit_program(1);
1874
    } else {
1875





171
        MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1876
    }
1877
1878
4846
    if (ost->stream_copy)
1879
171
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1880
1881
4846
    return ost;
1882
}
1883
1884
1233
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1885
{
1886
    int n;
1887
    AVStream *st;
1888
    OutputStream *ost;
1889
    AVCodecContext *audio_enc;
1890
1891
1233
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1892
1233
    st  = ost->st;
1893
1894
1233
    audio_enc = ost->enc_ctx;
1895
1233
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1896
1897





1234
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1898





1803
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1899
1900
1233
    if (!ost->stream_copy) {
1901
1123
        char *sample_fmt = NULL;
1902
1903





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





1123
        MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1906
1123
        if (sample_fmt &&
1907
            (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1908
            av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1909
            exit_program(1);
1910
        }
1911
1912





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





1123
        MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1915
1123
        ost->apad = av_strdup(ost->apad);
1916
1917
1123
        ost->avfilter = get_ost_filters(o, oc, ost);
1918
1123
        if (!ost->avfilter)
1919
            exit_program(1);
1920
1921
        /* check for channel mapping for this audio stream */
1922
1133
        for (n = 0; n < o->nb_audio_channel_maps; n++) {
1923
10
            AudioChannelMap *map = &o->audio_channel_maps[n];
1924

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

10
                (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1926
                InputStream *ist;
1927
1928
10
                if (map->channel_idx == -1) {
1929
1
                    ist = NULL;
1930
9
                } else if (ost->source_index < 0) {
1931
                    av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1932
                           ost->file_index, ost->st->index);
1933
                    continue;
1934
                } else {
1935
9
                    ist = input_streams[ost->source_index];
1936
                }
1937
1938

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





38
    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2004
2005
38
    if (!ost->stream_copy) {
2006
31
        char *frame_size = NULL;
2007
2008





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

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

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

83
    if (ost->avfilter && (ost->filters || ost->filters_script)) {
2112
        const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2113
        av_log(NULL, AV_LOG_ERROR,
2114
               "%s '%s' was specified through the %s option "
2115
               "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2116
               "%s and -filter_complex cannot be used together for the same stream.\n",
2117
               ost->filters ? "Filtergraph" : "Filtergraph script",
2118
               ost->filters ? ost->filters : ost->filters_script,
2119
               opt, ost->file_index, ost->index, opt);
2120
        exit_program(1);
2121
    }
2122
2123
83
    avfilter_inout_free(&ofilter->out_tmp);
2124
83
}
2125
2126
5980
static int init_complex_filters(void)
2127
{
2128
5980
    int i, ret = 0;
2129
2130
6060
    for (i = 0; i < nb_filtergraphs; i++) {
2131
80
        ret = init_complex_filtergraph(filtergraphs[i]);
2132
80
        if (ret < 0)
2133
            return ret;
2134
    }
2135
5980
    return 0;
2136
}
2137
2138
5981
static int open_output_file(OptionsContext *o, const char *filename)
2139
{
2140
    AVFormatContext *oc;
2141
    int i, j, err;
2142
    OutputFile *of;
2143
    OutputStream *ost;
2144
    InputStream  *ist;
2145
5981
    AVDictionary *unused_opts = NULL;
2146
5981
    AVDictionaryEntry *e = NULL;
2147
5981
    int format_flags = 0;
2148
2149

5981
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2150
        o->stop_time = INT64_MAX;
2151
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2152
    }
2153
2154

5981
    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2155
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2156
        if (o->stop_time <= start_time) {
2157
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2158
            exit_program(1);
2159
        } else {
2160
            o->recording_time = o->stop_time - start_time;
2161
        }
2162
    }
2163
2164
5981
    GROW_ARRAY(output_files, nb_output_files);
2165
5981
    of = av_mallocz(sizeof(*of));
2166
5981
    if (!of)
2167
        exit_program(1);
2168
5981
    output_files[nb_output_files - 1] = of;
2169
2170
5981
    of->ost_index      = nb_output_streams;
2171
5981
    of->recording_time = o->recording_time;
2172
5981
    of->start_time     = o->start_time;
2173
5981
    of->limit_filesize = o->limit_filesize;
2174
5981
    of->shortest       = o->shortest;
2175
5981
    av_dict_copy(&of->opts, o->g->format_opts, 0);
2176
2177
5981
    if (!strcmp(filename, "-"))
2178
2222
        filename = "pipe:";
2179
2180
5981
    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2181
5981
    if (!oc) {
2182
        print_error(filename, err);
2183
        exit_program(1);
2184
    }
2185
2186
5981
    of->ctx = oc;
2187
5981
    if (o->recording_time != INT64_MAX)
2188
129
        oc->duration = o->recording_time;
2189
2190
5981
    oc->interrupt_callback = int_cb;
2191
2192
5981
    e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2193
5981
    if (e) {
2194
3415
        const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2195
3415
        av_opt_eval_flags(oc, o, e->value, &format_flags);
2196
    }
2197
5981
    if (o->bitexact) {
2198
1646
        format_flags |= AVFMT_FLAG_BITEXACT;
2199
1646
        oc->flags    |= AVFMT_FLAG_BITEXACT;
2200
    }
2201
2202
    /* create streams for all unlabeled output pads */
2203
6062
    for (i = 0; i < nb_filtergraphs; i++) {
2204
81
        FilterGraph *fg = filtergraphs[i];
2205
165
        for (j = 0; j < fg->nb_outputs; j++) {
2206
84
            OutputFilter *ofilter = fg->outputs[j];
2207
2208

84
            if (!ofilter->out_tmp || ofilter->out_tmp->name)
2209
4
                continue;
2210
2211

80
            switch (ofilter->type) {
2212
66
            case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2213
14
            case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2214
            case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2215
            }
2216
80
            init_output_filter(ofilter, o, oc);
2217
        }
2218
    }
2219
2220
5981
    if (!o->nb_stream_maps) {
2221
5926
        char *subtitle_codec_name = NULL;
2222
        /* pick the "best" stream of each type */
2223
2224
        /* video: highest resolution */
2225

5926
        if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2226
5000
            int best_score = 0, idx = -1;
2227
5000
            int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2228
10279
            for (i = 0; i < nb_input_streams; i++) {
2229
                int score;
2230
5279
                ist = input_streams[i];
2231
10558
                score = ist->st->codecpar->width * ist->st->codecpar->height
2232
5279
                           + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
2233
5279
                           + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2234
5279
                if (ist->user_set_discard == AVDISCARD_ALL)
2235
                    continue;
2236

5279
                if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2237
8
                    score = 1;
2238

5279
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2239
                    score > best_score) {
2240

4755
                    if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2241
                        continue;
2242
4755
                    best_score = score;
2243
4755
                    idx = i;
2244
                }
2245
            }
2246
5000
            if (idx >= 0)
2247
4755
                new_video_stream(o, oc, idx);
2248
        }
2249
2250
        /* audio: most channels */
2251

5926
        if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2252
5034
            int best_score = 0, idx = -1;
2253
10240
            for (i = 0; i < nb_input_streams; i++) {
2254
                int score;
2255
5206
                ist = input_streams[i];
2256
5206
                score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2257
5206
                        + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2258
5206
                if (ist->user_set_discard == AVDISCARD_ALL)
2259
                    continue;
2260

5206
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2261
                    score > best_score) {
2262
1172
                    best_score = score;
2263
1172
                    idx = i;
2264
                }
2265
            }
2266
5034
            if (idx >= 0)
2267
1172
                new_audio_stream(o, oc, idx);
2268
        }
2269
2270
        /* subtitles: pick first */
2271

9383
        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2272

5926
        if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2273
58
            for (i = 0; i < nb_input_streams; i++)
2274
49
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2275
                    AVCodecDescriptor const *input_descriptor =
2276
35
                        avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2277
35
                    AVCodecDescriptor const *output_descriptor = NULL;
2278
                    AVCodec const *output_codec =
2279
35
                        avcodec_find_encoder(oc->oformat->subtitle_codec);
2280
35
                    int input_props = 0, output_props = 0;
2281
35
                    if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2282
                        continue;
2283
35
                    if (output_codec)
2284
33
                        output_descriptor = avcodec_descriptor_get(output_codec->id);
2285
35
                    if (input_descriptor)
2286
35
                        input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2287
35
                    if (output_descriptor)
2288
33
                        output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2289
35
                    if (subtitle_codec_name ||
2290

28
                        input_props & output_props ||
2291
                        // Map dvb teletext which has neither property to any output subtitle encoder
2292
                        input_descriptor && output_descriptor &&
2293
                        (!input_descriptor->props ||
2294
                         !output_descriptor->props)) {
2295
35
                        new_subtitle_stream(o, oc, i);
2296
35
                        break;
2297
                    }
2298
                }
2299
        }
2300
        /* Data only if codec id match */
2301
5926
        if (!o->data_disable ) {
2302
5926
            enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2303

5926
            for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2304
                if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2305
                    continue;
2306
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2307
                    && input_streams[i]->st->codecpar->codec_id == codec_id )
2308
                    new_data_stream(o, oc, i);
2309
            }
2310
        }
2311
    } else {
2312
140
        for (i = 0; i < o->nb_stream_maps; i++) {
2313
85
            StreamMap *map = &o->stream_maps[i];
2314
2315
85
            if (map->disabled)
2316
                continue;
2317
2318
85
            if (map->linklabel) {
2319
                FilterGraph *fg;
2320
3
                OutputFilter *ofilter = NULL;
2321
                int j, k;
2322
2323
3
                for (j = 0; j < nb_filtergraphs; j++) {
2324
3
                    fg = filtergraphs[j];
2325
3
                    for (k = 0; k < fg->nb_outputs; k++) {
2326
3
                        AVFilterInOut *out = fg->outputs[k]->out_tmp;
2327

3
                        if (out && !strcmp(out->name, map->linklabel)) {
2328
3
                            ofilter = fg->outputs[k];
2329
3
                            goto loop_end;
2330
                        }
2331
                    }
2332
                }
2333
loop_end:
2334
3
                if (!ofilter) {
2335
                    av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2336
                           "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2337
                    exit_program(1);
2338
                }
2339
3
                init_output_filter(ofilter, o, oc);
2340
            } else {
2341
82
                int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2342
2343
82
                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2344
82
                if (ist->user_set_discard == AVDISCARD_ALL) {
2345
                    av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2346
                           map->file_index, map->stream_index);
2347
                    exit_program(1);
2348
                }
2349

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

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

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

82
                if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2356
                    continue;
2357
2358
82
                ost = NULL;
2359

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

2
        if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2407
1
            !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2408
            av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2409
                   o->attachments[i]);
2410
            exit_program(1);
2411
        }
2412
1
        avio_read(pb, attachment, len);
2413
1
        memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2414
2415
1
        ost = new_attachment_stream(o, oc, -1);
2416
1
        ost->stream_copy               = 0;
2417
1
        ost->attachment_filename       = o->attachments[i];
2418
1
        ost->st->codecpar->extradata      = attachment;
2419
1
        ost->st->codecpar->extradata_size = len;
2420
2421
1
        p = strrchr(o->attachments[i], '/');
2422

1
        av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2423
1
        avio_closep(&pb);
2424
    }
2425
2426
#if FF_API_LAVF_AVCTX
2427
12109
    for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2428
        AVDictionaryEntry *e;
2429
6128
        ost = output_streams[i];
2430
2431

6128
        if ((ost->stream_copy || ost->attachment_filename)
2432
299
            && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2433

67
            && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2434
67
            if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2435
                exit_program(1);
2436
    }
2437
#endif
2438
2439

5981
    if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2440
        av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2441
        av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2442
        exit_program(1);
2443
    }
2444
2445
    /* check if all codec options have been used */
2446
5981
    unused_opts = strip_specifiers(o->g->codec_opts);
2447
12109
    for (i = of->ost_index; i < nb_output_streams; i++) {
2448
6128
        e = NULL;
2449
20140
        while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2450
                                AV_DICT_IGNORE_SUFFIX)))
2451
14012
            av_dict_set(&unused_opts, e->key, NULL, 0);
2452
    }
2453
2454
5981
    e = NULL;
2455
6251
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2456
270
        const AVClass *class = avcodec_get_class();
2457
270
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2458
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2459
270
        const AVClass *fclass = avformat_get_class();
2460
270
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2461
                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2462

270
        if (!option || foption)
2463
9
            continue;
2464
2465
2466
269
        if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2467
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2468
                   "output file #%d (%s) is not an encoding option.\n", e->key,
2469
                   option->help ? option->help : "", nb_output_files - 1,
2470
                   filename);
2471
            exit_program(1);
2472
        }
2473
2474
        // gop_timecode is injected by generic code but not always used
2475
269
        if (!strcmp(e->key, "gop_timecode"))
2476
8
            continue;
2477
2478
261
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2479
               "output file #%d (%s) has not been used for any stream. The most "
2480
               "likely reason is either wrong type (e.g. a video option with "
2481
               "no video streams) or that it is a private option of some encoder "
2482
               "which was not actually used for any stream.\n", e->key,
2483
261
               option->help ? option->help : "", nb_output_files - 1, filename);
2484
    }
2485
5981
    av_dict_free(&unused_opts);
2486
2487
    /* set the decoding_needed flags and create simple filtergraphs */
2488
12109
    for (i = of->ost_index; i < nb_output_streams; i++) {
2489
6128
        OutputStream *ost = output_streams[i];
2490
2491

6128
        if (ost->encoding_needed && ost->source_index >= 0) {
2492
5746
            InputStream *ist = input_streams[ost->source_index];
2493
5746
            ist->decoding_needed |= DECODING_FOR_OST;
2494
2495
5746
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2496
1139
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2497
5715
                err = init_simple_filtergraph(ist, ost);
2498
5715
                if (err < 0) {
2499
                    av_log(NULL, AV_LOG_ERROR,
2500
                           "Error initializing a simple filtergraph between streams "
2501
                           "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2502
                           nb_output_files - 1, ost->st->index);
2503
                    exit_program(1);
2504
                }
2505
            }
2506
        }
2507
2508
        /* set the filter output constraints */
2509
6128
        if (ost->filter) {
2510
5798
            OutputFilter *f = ost->filter;
2511
            int count;
2512
5798
            switch (ost->enc_ctx->codec_type) {
2513
4675
            case AVMEDIA_TYPE_VIDEO:
2514
4675
                f->frame_rate = ost->frame_rate;
2515
4675
                f->width      = ost->enc_ctx->width;
2516
4675
                f->height     = ost->enc_ctx->height;
2517
4675
                if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2518
3365
                    f->format = ost->enc_ctx->pix_fmt;
2519
1310
                } else if (ost->enc->pix_fmts) {
2520
290
                    count = 0;
2521
1474
                    while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2522
1184
                        count++;
2523
290
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2524
290
                    if (!f->formats)
2525
                        exit_program(1);
2526
290
                    memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2527
                }
2528
4675
                break;
2529
1123
            case AVMEDIA_TYPE_AUDIO:
2530
1123
                if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2531
                    f->format = ost->enc_ctx->sample_fmt;
2532
1123
                } else if (ost->enc->sample_fmts) {
2533
1123
                    count = 0;
2534
2283
                    while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2535
1160
                        count++;
2536
1123
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2537
1123
                    if (!f->formats)
2538
                        exit_program(1);
2539
1123
                    memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2540
                }
2541
1123
                if (ost->enc_ctx->sample_rate) {
2542
25
                    f->sample_rate = ost->enc_ctx->sample_rate;
2543
1098
                } else if (ost->enc->supported_samplerates) {
2544
35
                    count = 0;
2545
305
                    while (ost->enc->supported_samplerates[count])
2546
270
                        count++;
2547
35
                    f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2548
35
                    if (!f->sample_rates)
2549
                        exit_program(1);
2550
35
                    memcpy(f->sample_rates, ost->enc->supported_samplerates,
2551
35
                           (count + 1) * sizeof(*f->sample_rates));
2552
                }
2553
1123
                if (ost->enc_ctx->channels) {
2554
12
                    f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2555
1111
                } else if (ost->enc->channel_layouts) {
2556
42
                    count = 0;
2557
280
                    while (ost->enc->channel_layouts[count])
2558
238
                        count++;
2559
42
                    f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2560
42
                    if (!f->channel_layouts)
2561
                        exit_program(1);
2562
42
                    memcpy(f->channel_layouts, ost->enc->channel_layouts,
2563
42
                           (count + 1) * sizeof(*f->channel_layouts));
2564
                }
2565
1123
                break;
2566
            }
2567
6128
        }
2568
    }
2569
2570
    /* check filename in case of an image number is expected */
2571
5981
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2572
        if (!av_filename_number_test(oc->url)) {
2573
            print_error(oc->url, AVERROR(EINVAL));
2574
            exit_program(1);
2575
        }
2576
    }
2577
2578

5981
    if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2579
        av_log(NULL, AV_LOG_ERROR,
2580
               "No input streams but output needs an input stream\n");
2581
        exit_program(1);
2582
    }
2583
2584
5981
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2585
        /* test if it already exists to avoid losing precious files */
2586
5927
        assert_file_overwrite(filename);
2587
2588
        /* open the file */
2589
5927
        if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2590
5927
                              &oc->interrupt_callback,
2591
                              &of->opts)) < 0) {
2592
            print_error(filename, err);
2593
            exit_program(1);
2594
        }
2595

54
    } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2596
        assert_file_overwrite(filename);
2597
2598
5981
    if (o->mux_preload) {
2599
        av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2600
    }
2601
5981
    oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2602
2603
    /* copy metadata */
2604
5986
    for (i = 0; i < o->nb_metadata_map; i++) {
2605
        char *p;
2606
5
        int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2607
2608
5
        if (in_file_index >= nb_input_files) {
2609
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2610
            exit_program(1);
2611
        }
2612

8
        copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2613
                      in_file_index >= 0 ?
2614
3
                      input_files[in_file_index]->ctx : NULL, o);
2615
    }
2616
2617
    /* copy chapters */
2618
5981
    if (o->chapters_input_file >= nb_input_files) {
2619
5981
        if (o->chapters_input_file == INT_MAX) {
2620
            /* copy chapters from the first input file that has them*/
2621
5981
            o->chapters_input_file = -1;
2622
11977
            for (i = 0; i < nb_input_files; i++)
2623
6009
                if (input_files[i]->ctx->nb_chapters) {
2624
13
                    o->chapters_input_file = i;
2625
13
                    break;
2626
                }
2627
        } else {
2628
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2629
                   o->chapters_input_file);
2630
            exit_program(1);
2631
        }
2632
    }
2633
5981
    if (o->chapters_input_file >= 0)
2634
13
        copy_chapters(input_files[o->chapters_input_file], of,
2635
13
                      !o->metadata_chapters_manual);
2636
2637
    /* copy global metadata by default */
2638

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

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