GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg_opt.c Lines: 1146 1980 57.9 %
Date: 2021-04-18 10:33:33 Branches: 919 2428 37.9 %

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

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

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

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

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

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

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

44
        switch (*arg) {
613
18
        case 'g':
614
18
            break;
615
22
        case 's':
616

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

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

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

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

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

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

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



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



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

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





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





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





6404
        MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
820
821





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





6404
        MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
834
835





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

6404
        if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
839

6404
            (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
840

6404
            (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
841

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

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

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





4915
            MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
876

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





4891
            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
885
886





9541
            MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
887





4891
            MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
888
                                 hwaccel_output_format, ic, st);
889
890

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

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





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





1412
            MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
961
1408
            guess_input_channel_layout(ist);
962
1408
            break;
963
104
        case AVMEDIA_TYPE_DATA:
964
        case AVMEDIA_TYPE_SUBTITLE: {
965
104
            char *canvas_size = NULL;
966
104
            if(!ist->dec)
967
50
                ist->dec = avcodec_find_decoder(par->codec_id);
968





104
            MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
969





104
            MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
970

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

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

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

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

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

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

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

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

8479
    MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
1146

8479
    MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
1147

8479
    MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1148

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

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

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

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

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

6193
    if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1395





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





5846
        MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1480
5846
        ost->autoscale = 1;
1481





5846
        MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1482

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





6194
    MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1514
6193
    if (time_base) {
1515
        AVRational q;
1516
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1517

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





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





18078
    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1537
10460
    for (i = 0; i<o->nb_max_frames; i++) {
1538
4273
        char *p = o->max_frames[i].specifier;
1539

4273
        if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1540
6
            av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1541
6
            break;
1542
        }
1543
    }
1544
1545
6193
    ost->copy_prior_start = -1;
1546





6193
    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1547
1548





6290
    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1549

6193
    if (bsfs && *bsfs) {
1550
88
        ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1551
88
        if (ret < 0) {
1552
            av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1553
            exit_program(1);
1554
        }
1555
    }
1556
1557





6199
    MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1558
6193
    if (codec_tag) {
1559
6
        uint32_t tag = strtol(codec_tag, &next, 0);
1560
6
        if (*next)
1561
6
            tag = AV_RL32(codec_tag);
1562
6
        ost->st->codecpar->codec_tag =
1563
6
        ost->enc_ctx->codec_tag = tag;
1564
    }
1565
1566





6479
    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1567
6193
    if (qscale >= 0) {
1568
232
        ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1569
232
        ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1570
    }
1571
1572





6228
    MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1573
6193
    ost->disposition = av_strdup(ost->disposition);
1574
1575
6193
    ost->max_muxing_queue_size = 128;
1576





6195
    MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1577
6193
    ost->max_muxing_queue_size *= sizeof(ost->pkt);
1578
1579
6193
    ost->muxing_queue_data_size = 0;
1580
1581
6193
    ost->muxing_queue_data_threshold = 50*1024*1024;
1582





6193
    MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st);
1583
1584
6193
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1585
2365
        ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1586
1587
6193
    av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1588
1589
6193
    av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1590

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

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

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





4902
    MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1702

4881
    if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1703
        av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1704
        exit_program(1);
1705
    }
1706
1707





4881
    MATCH_PER_STREAM_OPT(max_frame_rates, str, max_frame_rate, oc, st);
1708

4881
    if (max_frame_rate && av_parse_video_rate(&ost->max_frame_rate, max_frame_rate) < 0) {
1709
        av_log(NULL, AV_LOG_FATAL, "Invalid maximum framerate value: %s\n", max_frame_rate);
1710
        exit_program(1);
1711
    }
1712
1713

4881
    if (frame_rate && max_frame_rate) {
1714
        av_log(NULL, AV_LOG_ERROR, "Only one of -fpsmax and -r can be set for a stream.\n");
1715
        exit_program(1);
1716
    }
1717
1718

4881
    if ((frame_rate || max_frame_rate) &&
1719
21
        video_sync_method == VSYNC_PASSTHROUGH)
1720
        av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r/-fpsmax can produce invalid output files\n");
1721
1722





4881
    MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1723
4881
    if (frame_aspect_ratio) {
1724
        AVRational q;
1725
        if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1726
            q.num <= 0 || q.den <= 0) {
1727
            av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1728
            exit_program(1);
1729
        }
1730
        ost->frame_aspect_ratio = q;
1731
    }
1732
1733





4884
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1734





7453
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1735
1736
4881
    if (!ost->stream_copy) {
1737
4686
        const char *p = NULL;
1738
4686
        char *frame_size = NULL;
1739
4686
        char *frame_pix_fmt = NULL;
1740
4686
        char *intra_matrix = NULL, *inter_matrix = NULL;
1741
4686
        char *chroma_intra_matrix = NULL;
1742
4686
        int do_pass = 0;
1743
        int i;
1744
1745





5301
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1746

4686
        if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1747
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1748
            exit_program(1);
1749
        }
1750
1751
4686
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1752





8051
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1753

4686
        if (frame_pix_fmt && *frame_pix_fmt == '+') {
1754
            ost->keep_pix_fmt = 1;
1755
            if (!*++frame_pix_fmt)
1756
                frame_pix_fmt = NULL;
1757
        }
1758

4686
        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1759
            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1760
            exit_program(1);
1761
        }
1762
4686
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1763
1764
4686
        if (intra_only)
1765
            video_enc->gop_size = 0;
1766





4686
        MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1767
4686
        if (intra_matrix) {
1768
            if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1769
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1770
                exit_program(1);
1771
            }
1772
            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1773
        }
1774





4686
        MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1775
4686
        if (chroma_intra_matrix) {
1776
            uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1777
            if (!p) {
1778
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1779
                exit_program(1);
1780
            }
1781
            video_enc->chroma_intra_matrix = p;
1782
            parse_matrix_coeffs(p, chroma_intra_matrix);
1783
        }
1784





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





4686
        MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1794
4686
        for (i = 0; p; i++) {
1795
            int start, end, q;
1796
            int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1797
            if (e != 3) {
1798
                av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1799
                exit_program(1);
1800
            }
1801
            video_enc->rc_override =
1802
                av_realloc_array(video_enc->rc_override,
1803
                                 i + 1, sizeof(RcOverride));
1804
            if (!video_enc->rc_override) {
1805
                av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1806
                exit_program(1);
1807
            }
1808
            video_enc->rc_override[i].start_frame = start;
1809
            video_enc->rc_override[i].end_frame   = end;
1810
            if (q > 0) {
1811
                video_enc->rc_override[i].qscale         = q;
1812
                video_enc->rc_override[i].quality_factor = 1.0;
1813
            }
1814
            else {
1815
                video_enc->rc_override[i].qscale         = 0;
1816
                video_enc->rc_override[i].quality_factor = -q/100.0;
1817
            }
1818
            p = strchr(p, '/');
1819
            if (p) p++;
1820
        }
1821
4686
        video_enc->rc_override_count = i;
1822
1823
4686
        if (do_psnr)
1824
            video_enc->flags|= AV_CODEC_FLAG_PSNR;
1825
1826
        /* two pass mode */
1827





4686
        MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1828
4686
        if (do_pass) {
1829
            if (do_pass & 1) {
1830
                video_enc->flags |= AV_CODEC_FLAG_PASS1;
1831
                av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1832
            }
1833
            if (do_pass & 2) {
1834
                video_enc->flags |= AV_CODEC_FLAG_PASS2;
1835
                av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1836
            }
1837
        }
1838
1839





4686
        MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1840
4686
        if (ost->logfile_prefix &&
1841
            !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1842
            exit_program(1);
1843
1844
4686
        if (do_pass) {
1845
            char logfilename[1024];
1846
            FILE *f;
1847
1848
            snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1849
                     ost->logfile_prefix ? ost->logfile_prefix :
1850
                                           DEFAULT_PASS_LOGFILENAME_PREFIX,
1851
                     i);
1852
            if (!strcmp(ost->enc->name, "libx264")) {
1853
                av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1854
            } else {
1855
                if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1856
                    char  *logbuffer = read_file(logfilename);
1857
1858
                    if (!logbuffer) {
1859
                        av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1860
                               logfilename);
1861
                        exit_program(1);
1862
                    }
1863
                    video_enc->stats_in = logbuffer;
1864
                }
1865
                if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1866
                    f = av_fopen_utf8(logfilename, "wb");
1867
                    if (!f) {
1868
                        av_log(NULL, AV_LOG_FATAL,
1869
                               "Cannot write log file '%s' for pass-1 encoding: %s\n",
1870
                               logfilename, strerror(errno));
1871
                        exit_program(1);
1872
                    }
1873
                    ost->logfile = f;
1874
                }
1875
            }
1876
        }
1877
1878





4687
        MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1879
4686
        if (ost->forced_keyframes)
1880
1
            ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1881
1882





4686
        MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1883
1884
4686
        ost->top_field_first = -1;
1885





4689
        MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1886
1887
1888
4686
        ost->avfilter = get_ost_filters(o, oc, ost);
1889
4686
        if (!ost->avfilter)
1890
            exit_program(1);
1891
    } else {
1892





195
        MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1893
    }
1894
1895
4881
    if (ost->stream_copy)
1896
195
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1897
1898
4881
    return ost;
1899
}
1900
1901
1254
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1902
{
1903
    int n;
1904
    AVStream *st;
1905
    OutputStream *ost;
1906
    AVCodecContext *audio_enc;
1907
1908
1254
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1909
1254
    st  = ost->st;
1910
1911
1254
    audio_enc = ost->enc_ctx;
1912
1254
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1913
1914





1255
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1915





1843
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1916
1917
1254
    if (!ost->stream_copy) {
1918
1128
        char *sample_fmt = NULL;
1919
1920





1140
        MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1921
1922





1128
        MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1923
1128
        if (sample_fmt &&
1924
            (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1925
            av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1926
            exit_program(1);
1927
        }
1928
1929





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





1128
        MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1932
1128
        ost->apad = av_strdup(ost->apad);
1933
1934
1128
        ost->avfilter = get_ost_filters(o, oc, ost);
1935
1128
        if (!ost->avfilter)
1936
            exit_program(1);
1937
1938
        /* check for channel mapping for this audio stream */
1939
1138
        for (n = 0; n < o->nb_audio_channel_maps; n++) {
1940
10
            AudioChannelMap *map = &o->audio_channel_maps[n];
1941

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

10
                (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1943
                InputStream *ist;
1944
1945
10
                if (map->channel_idx == -1) {
1946
1
                    ist = NULL;
1947
9
                } else if (ost->source_index < 0) {
1948
                    av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1949
                           ost->file_index, ost->st->index);
1950
                    continue;
1951
                } else {
1952
9
                    ist = input_streams[ost->source_index];
1953
                }
1954
1955

10
                if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1956
10
                    if (av_reallocp_array(&ost->audio_channels_map,
1957
10
                                          ost->audio_channels_mapped + 1,
1958
                                          sizeof(*ost->audio_channels_map)
1959
                                          ) < 0 )
1960
                        exit_program(1);
1961
1962
10
                    ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1963
                }
1964
            }
1965
        }
1966
    }
1967
1968
1254
    if (ost->stream_copy)
1969
126
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1970
1971
1254
    return ost;
1972
}
1973
1974
10
static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1975
{
1976
    OutputStream *ost;
1977
1978
10
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1979
10
    if (!ost->stream_copy) {
1980
        av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1981
        exit_program(1);
1982
    }
1983
1984
10
    return ost;
1985
}
1986
1987
static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1988
{
1989
    OutputStream *ost;
1990
1991
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1992
    if (!ost->stream_copy) {
1993
        av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1994
        exit_program(1);
1995
    }
1996
1997
    return ost;
1998
}
1999
2000
1
static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2001
{
2002
1
    OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
2003
1
    ost->stream_copy = 1;
2004
1
    ost->finished    = 1;
2005
1
    return ost;
2006
}
2007
2008
47
static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
2009
{
2010
    AVStream *st;
2011
    OutputStream *ost;
2012
    AVCodecContext *subtitle_enc;
2013
2014
47
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
2015
47
    st  = ost->st;
2016
47
    subtitle_enc = ost->enc_ctx;
2017
2018
47
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
2019
2020





47
    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2021
2022
47
    if (!ost->stream_copy) {
2023
32
        char *frame_size = NULL;
2024
2025





32
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
2026

32
        if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
2027
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2028
            exit_program(1);
2029
        }
2030
    }
2031
2032
47
    return ost;
2033
}
2034
2035
/* arg format is "output-stream-index:streamid-value". */
2036
static int opt_streamid(void *optctx, const char *opt, const char *arg)
2037
{
2038
    OptionsContext *o = optctx;
2039
    int idx;
2040
    char *p;
2041
    char idx_str[16];
2042
2043
    av_strlcpy(idx_str, arg, sizeof(idx_str));
2044
    p = strchr(idx_str, ':');
2045
    if (!p) {
2046
        av_log(NULL, AV_LOG_FATAL,
2047
               "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2048
               arg, opt);
2049
        exit_program(1);
2050
    }
2051
    *p++ = '\0';
2052
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2053
    o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2054
    o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2055
    return 0;
2056
}
2057
2058
15
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
2059
{
2060
15
    AVFormatContext *is = ifile->ctx;
2061
15
    AVFormatContext *os = ofile->ctx;
2062
    AVChapter **tmp;
2063
    int i;
2064
2065
15
    tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2066
15
    if (!tmp)
2067
        return AVERROR(ENOMEM);
2068
15
    os->chapters = tmp;
2069
2070
37
    for (i = 0; i < is->nb_chapters; i++) {
2071
24
        AVChapter *in_ch = is->chapters[i], *out_ch;
2072
24
        int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2073
24
        int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
2074
24
                                       AV_TIME_BASE_Q, in_ch->time_base);
2075
24
        int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2076
3
                           av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2077
2078
2079
24
        if (in_ch->end < ts_off)
2080
            continue;
2081

24
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2082
2
            break;
2083
2084
22
        out_ch = av_mallocz(sizeof(AVChapter));
2085
22
        if (!out_ch)
2086
            return AVERROR(ENOMEM);
2087
2088
22
        out_ch->id        = in_ch->id;
2089
22
        out_ch->time_base = in_ch->time_base;
2090
22
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
2091
22
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
2092
2093
22
        if (copy_metadata)
2094
22
            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2095
2096
22
        os->chapters[os->nb_chapters++] = out_ch;
2097
    }
2098
15
    return 0;
2099
}
2100
2101
83
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2102
                               AVFormatContext *oc)
2103
{
2104
    OutputStream *ost;
2105
2106
83
    switch (ofilter->type) {
2107
68
    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2108
15
    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2109
    default:
2110
        av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2111
               "currently.\n");
2112
        exit_program(1);
2113
    }
2114
2115
83
    ost->source_index = -1;
2116
83
    ost->filter       = ofilter;
2117
2118
83
    ofilter->ost      = ost;
2119
83
    ofilter->format   = -1;
2120
2121
83
    if (ost->stream_copy) {
2122
        av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2123
               "which is fed from a complex filtergraph. Filtering and streamcopy "
2124
               "cannot be used together.\n", ost->file_index, ost->index);
2125
        exit_program(1);
2126
    }
2127
2128

83
    if (ost->avfilter && (ost->filters || ost->filters_script)) {
2129
        const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2130
        av_log(NULL, AV_LOG_ERROR,
2131
               "%s '%s' was specified through the %s option "
2132
               "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2133
               "%s and -filter_complex cannot be used together for the same stream.\n",
2134
               ost->filters ? "Filtergraph" : "Filtergraph script",
2135
               ost->filters ? ost->filters : ost->filters_script,
2136
               opt, ost->file_index, ost->index, opt);
2137
        exit_program(1);
2138
    }
2139
2140
83
    avfilter_inout_free(&ofilter->out_tmp);
2141
83
}
2142
2143
6010
static int init_complex_filters(void)
2144
{
2145
6010
    int i, ret = 0;
2146
2147
6090
    for (i = 0; i < nb_filtergraphs; i++) {
2148
80
        ret = init_complex_filtergraph(filtergraphs[i]);
2149
80
        if (ret < 0)
2150
            return ret;
2151
    }
2152
6010
    return 0;
2153
}
2154
2155
6011
static int open_output_file(OptionsContext *o, const char *filename)
2156
{
2157
    AVFormatContext *oc;
2158
    int i, j, err;
2159
    OutputFile *of;
2160
    OutputStream *ost;
2161
    InputStream  *ist;
2162
6011
    AVDictionary *unused_opts = NULL;
2163
6011
    AVDictionaryEntry *e = NULL;
2164
6011
    int format_flags = 0;
2165
2166

6011
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2167
        o->stop_time = INT64_MAX;
2168
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2169
    }
2170
2171

6011
    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2172
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2173
        if (o->stop_time <= start_time) {
2174
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2175
            exit_program(1);
2176
        } else {
2177
            o->recording_time = o->stop_time - start_time;
2178
        }
2179
    }
2180
2181
6011
    GROW_ARRAY(output_files, nb_output_files);
2182
6011
    of = av_mallocz(sizeof(*of));
2183
6011
    if (!of)
2184
        exit_program(1);
2185
6011
    output_files[nb_output_files - 1] = of;
2186
2187
6011
    of->ost_index      = nb_output_streams;
2188
6011
    of->recording_time = o->recording_time;
2189
6011
    of->start_time     = o->start_time;
2190
6011
    of->limit_filesize = o->limit_filesize;
2191
6011
    of->shortest       = o->shortest;
2192
6011
    av_dict_copy(&of->opts, o->g->format_opts, 0);
2193
2194
6011
    if (!strcmp(filename, "-"))
2195
2239
        filename = "pipe:";
2196
2197
6011
    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2198
6011
    if (!oc) {
2199
        print_error(filename, err);
2200
        exit_program(1);
2201
    }
2202
2203
6011
    of->ctx = oc;
2204
6011
    if (o->recording_time != INT64_MAX)
2205
137
        oc->duration = o->recording_time;
2206
2207
6011
    oc->interrupt_callback = int_cb;
2208
2209
6011
    e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2210
6011
    if (e) {
2211
3440
        const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2212
3440
        av_opt_eval_flags(oc, o, e->value, &format_flags);
2213
    }
2214
6011
    if (o->bitexact) {
2215
1649
        format_flags |= AVFMT_FLAG_BITEXACT;
2216
1649
        oc->flags    |= AVFMT_FLAG_BITEXACT;
2217
    }
2218
2219
    /* create streams for all unlabeled output pads */
2220
6092
    for (i = 0; i < nb_filtergraphs; i++) {
2221
81
        FilterGraph *fg = filtergraphs[i];
2222
165
        for (j = 0; j < fg->nb_outputs; j++) {
2223
84
            OutputFilter *ofilter = fg->outputs[j];
2224
2225

84
            if (!ofilter->out_tmp || ofilter->out_tmp->name)
2226
4
                continue;
2227
2228

80
            switch (ofilter->type) {
2229
66
            case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2230
14
            case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2231
            case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2232
            }
2233
80
            init_output_filter(ofilter, o, oc);
2234
        }
2235
    }
2236
2237
6011
    if (!o->nb_stream_maps) {
2238
5940
        char *subtitle_codec_name = NULL;
2239
        /* pick the "best" stream of each type */
2240
2241
        /* video: highest resolution */
2242

5940
        if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2243
5012
            int best_score = 0, idx = -1;
2244
5012
            int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2245
10304
            for (i = 0; i < nb_input_streams; i++) {
2246
                int score;
2247
5292
                ist = input_streams[i];
2248
10584
                score = ist->st->codecpar->width * ist->st->codecpar->height
2249
5292
                           + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
2250
5292
                           + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2251
5292
                if (ist->user_set_discard == AVDISCARD_ALL)
2252
                    continue;
2253

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

5292
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2256
                    score > best_score) {
2257

4760
                    if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2258
                        continue;
2259
4760
                    best_score = score;
2260
4760
                    idx = i;
2261
                }
2262
            }
2263
5012
            if (idx >= 0)
2264
4760
                new_video_stream(o, oc, idx);
2265
        }
2266
2267
        /* audio: most channels */
2268

5940
        if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2269
5046
            int best_score = 0, idx = -1;
2270
10263
            for (i = 0; i < nb_input_streams; i++) {
2271
                int score;
2272
5217
                ist = input_streams[i];
2273
5217
                score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2274
5217
                        + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2275
5217
                if (ist->user_set_discard == AVDISCARD_ALL)
2276
                    continue;
2277

5217
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2278
                    score > best_score) {
2279
1177
                    best_score = score;
2280
1177
                    idx = i;
2281
                }
2282
            }
2283
5046
            if (idx >= 0)
2284
1177
                new_audio_stream(o, oc, idx);
2285
        }
2286
2287
        /* subtitles: pick first */
2288

9407
        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2289

5940
        if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2290
63
            for (i = 0; i < nb_input_streams; i++)
2291
53
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2292
                    AVCodecDescriptor const *input_descriptor =
2293
38
                        avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2294
38
                    AVCodecDescriptor const *output_descriptor = NULL;
2295
                    AVCodec const *output_codec =
2296
38
                        avcodec_find_encoder(oc->oformat->subtitle_codec);
2297
38
                    int input_props = 0, output_props = 0;
2298
38
                    if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2299
                        continue;
2300
38
                    if (output_codec)
2301
35
                        output_descriptor = avcodec_descriptor_get(output_codec->id);
2302
38
                    if (input_descriptor)
2303
38
                        input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2304
38
                    if (output_descriptor)
2305
35
                        output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2306
38
                    if (subtitle_codec_name ||
2307

29
                        input_props & output_props ||
2308
                        // Map dvb teletext which has neither property to any output subtitle encoder
2309
                        input_descriptor && output_descriptor &&
2310
                        (!input_descriptor->props ||
2311
                         !output_descriptor->props)) {
2312
38
                        new_subtitle_stream(o, oc, i);
2313
38
                        break;
2314
                    }
2315
                }
2316
        }
2317
        /* Data only if codec id match */
2318
5940
        if (!o->data_disable ) {
2319
5940
            enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2320

5940
            for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2321
                if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2322
                    continue;
2323
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2324
                    && input_streams[i]->st->codecpar->codec_id == codec_id )
2325
                    new_data_stream(o, oc, i);
2326
            }
2327
        }
2328
    } else {
2329
208
        for (i = 0; i < o->nb_stream_maps; i++) {
2330
137
            StreamMap *map = &o->stream_maps[i];
2331
2332
137
            if (map->disabled)
2333
                continue;
2334
2335
137
            if (map->linklabel) {
2336
                FilterGraph *fg;
2337
3
                OutputFilter *ofilter = NULL;
2338
                int j, k;
2339
2340
3
                for (j = 0; j < nb_filtergraphs; j++) {
2341
3
                    fg = filtergraphs[j];
2342
3
                    for (k = 0; k < fg->nb_outputs; k++) {
2343
3
                        AVFilterInOut *out = fg->outputs[k]->out_tmp;
2344

3
                        if (out && !strcmp(out->name, map->linklabel)) {
2345
3
                            ofilter = fg->outputs[k];
2346
3
                            goto loop_end;
2347
                        }
2348
                    }
2349
                }
2350
loop_end:
2351
3
                if (!ofilter) {
2352
                    av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2353
                           "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2354
                    exit_program(1);
2355
                }
2356
3
                init_output_filter(ofilter, o, oc);
2357
            } else {
2358
134
                int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2359
2360
134
                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2361
134
                if (ist->user_set_discard == AVDISCARD_ALL) {
2362
                    av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2363
                           map->file_index, map->stream_index);
2364
                    exit_program(1);
2365
                }
2366

134
                if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2367
                    continue;
2368

134
                if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2369
                    continue;
2370

134
                if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2371
                    continue;
2372

134
                if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2373
                    continue;
2374
2375
134
                ost = NULL;
2376

134
                switch (ist->st->codecpar->codec_type) {
2377
53
                case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2378
62
                case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2379
9
                case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2380
10
                case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2381
                case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2382
                case AVMEDIA_TYPE_UNKNOWN:
2383
                    if (copy_unknown_streams) {
2384
                        ost = new_unknown_stream   (o, oc, src_idx);
2385
                        break;
2386
                    }
2387
                default:
2388
                    av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2389
                           "Cannot map stream #%d:%d - unsupported type.\n",
2390
                           map->file_index, map->stream_index);
2391
                    if (!ignore_unknown_streams) {
2392
                        av_log(NULL, AV_LOG_FATAL,
2393
                               "If you want unsupported types ignored instead "
2394
                               "of failing, please use the -ignore_unknown option\n"
2395
                               "If you want them copied, please use -copy_unknown\n");
2396
                        exit_program(1);
2397
                    }
2398
                }
2399
134
                if (ost)
2400
134
                    ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2401
134
                                                  + map->sync_stream_index];
2402
            }
2403
        }
2404
    }
2405
2406
    /* handle attached files */
2407
6012
    for (i = 0; i < o->nb_attachments; i++) {
2408
        AVIOContext *pb;
2409
        uint8_t *attachment;
2410
        const char *p;
2411
        int64_t len;
2412
2413
1
        if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2414
            av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2415
                   o->attachments[i]);
2416
            exit_program(1);
2417
        }
2418
1
        if ((len = avio_size(pb)) <= 0) {
2419
            av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2420
                   o->attachments[i]);
2421
            exit_program(1);
2422
        }
2423

2
        if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2424
1
            !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2425
            av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2426
                   o->attachments[i]);
2427
            exit_program(1);
2428
        }
2429
1
        avio_read(pb, attachment, len);
2430
1
        memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2431
2432
1
        ost = new_attachment_stream(o, oc, -1);
2433
1
        ost->stream_copy               = 0;
2434
1
        ost->attachment_filename       = o->attachments[i];
2435
1
        ost->st->codecpar->extradata      = attachment;
2436
1
        ost->st->codecpar->extradata_size = len;
2437
2438
1
        p = strrchr(o->attachments[i], '/');
2439

1
        av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2440
1
        avio_closep(&pb);
2441
    }
2442
2443
#if FF_API_LAVF_AVCTX
2444
12204
    for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2445
        AVDictionaryEntry *e;
2446
6193
        ost = output_streams[i];
2447
2448

6193
        if ((ost->stream_copy || ost->attachment_filename)
2449
347
            && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2450

116
            && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2451
116
            if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2452
                exit_program(1);
2453
    }
2454
#endif
2455
2456

6011
    if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2457
        av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2458
        av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2459
        exit_program(1);
2460
    }
2461
2462
    /* check if all codec options have been used */
2463
6011
    unused_opts = strip_specifiers(o->g->codec_opts);
2464
12204
    for (i = of->ost_index; i < nb_output_streams; i++) {
2465
6193
        e = NULL;
2466
20455
        while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2467
                                AV_DICT_IGNORE_SUFFIX)))
2468
14262
            av_dict_set(&unused_opts, e->key, NULL, 0);
2469
    }
2470
2471
6011
    e = NULL;
2472
6281
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2473
270
        const AVClass *class = avcodec_get_class();
2474
270
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2475
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2476
270
        const AVClass *fclass = avformat_get_class();
2477
270
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2478
                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2479

270
        if (!option || foption)
2480
9
            continue;
2481
2482
2483
269
        if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2484
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2485
                   "output file #%d (%s) is not an encoding option.\n", e->key,
2486
                   option->help ? option->help : "", nb_output_files - 1,
2487
                   filename);
2488
            exit_program(1);
2489
        }
2490
2491
        // gop_timecode is injected by generic code but not always used
2492
269
        if (!strcmp(e->key, "gop_timecode"))
2493
8
            continue;
2494
2495
261
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2496
               "output file #%d (%s) has not been used for any stream. The most "
2497
               "likely reason is either wrong type (e.g. a video option with "
2498
               "no video streams) or that it is a private option of some encoder "
2499
               "which was not actually used for any stream.\n", e->key,
2500
261
               option->help ? option->help : "", nb_output_files - 1, filename);
2501
    }
2502
6011
    av_dict_free(&unused_opts);
2503
2504
    /* set the decoding_needed flags and create simple filtergraphs */
2505
12204
    for (i = of->ost_index; i < nb_output_streams; i++) {
2506
6193
        OutputStream *ost = output_streams[i];
2507
2508

6193
        if (ost->encoding_needed && ost->source_index >= 0) {
2509
5763
            InputStream *ist = input_streams[ost->source_index];
2510
5763
            ist->decoding_needed |= DECODING_FOR_OST;
2511
2512
5763
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2513
1145
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2514
5731
                err = init_simple_filtergraph(ist, ost);
2515
5731
                if (err < 0) {
2516
                    av_log(NULL, AV_LOG_ERROR,
2517
                           "Error initializing a simple filtergraph between streams "
2518
                           "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2519
                           nb_output_files - 1, ost->st->index);
2520
                    exit_program(1);
2521
                }
2522
            }
2523
        }
2524
2525
        /* set the filter output constraints */
2526
6193
        if (ost->filter) {
2527
5814
            OutputFilter *f = ost->filter;
2528
            int count;
2529
5814
            switch (ost->enc_ctx->codec_type) {
2530
4686
            case AVMEDIA_TYPE_VIDEO:
2531
4686
                f->frame_rate = ost->frame_rate;
2532
4686
                f->width      = ost->enc_ctx->width;
2533
4686
                f->height     = ost->enc_ctx->height;
2534
4686
                if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2535
3365
                    f->format = ost->enc_ctx->pix_fmt;
2536
1321
                } else if (ost->enc->pix_fmts) {
2537
297
                    count = 0;
2538
1593
                    while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2539
1296
                        count++;
2540
297
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2541
297
                    if (!f->formats)
2542
                        exit_program(1);
2543
297
                    memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2544
                }
2545
4686
                break;
2546
1128
            case AVMEDIA_TYPE_AUDIO:
2547
1128
                if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2548
                    f->format = ost->enc_ctx->sample_fmt;
2549
1128
                } else if (ost->enc->sample_fmts) {
2550
1128
                    count = 0;
2551
2293
                    while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2552
1165
                        count++;
2553
1128
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2554
1128
                    if (!f->formats)
2555
                        exit_program(1);
2556
1128
                    memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2557
                }
2558
1128
                if (ost->enc_ctx->sample_rate) {
2559
25
                    f->sample_rate = ost->enc_ctx->sample_rate;
2560
1103
                } else if (ost->enc->supported_samplerates) {
2561
35
                    count = 0;
2562
305
                    while (ost->enc->supported_samplerates[count])
2563
270
                        count++;
2564
35
                    f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2565
35
                    if (!f->sample_rates)
2566
                        exit_program(1);
2567
35
                    memcpy(f->sample_rates, ost->enc->supported_samplerates,
2568
35
                           (count + 1) * sizeof(*f->sample_rates));
2569
                }
2570
1128
                if (ost->enc_ctx->channels) {
2571
12
                    f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2572
1116
                } else if (ost->enc->channel_layouts) {
2573
42
                    count = 0;
2574
280
                    while (ost->enc->channel_layouts[count])
2575
238
                        count++;
2576
42
                    f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2577
42
                    if (!f->channel_layouts)
2578
                        exit_program(1);
2579
42
                    memcpy(f->channel_layouts, ost->enc->channel_layouts,
2580
42
                           (count + 1) * sizeof(*f->channel_layouts));
2581
                }
2582
1128
                break;
2583
            }
2584
6193
        }
2585
    }
2586
2587
    /* check filename in case of an image number is expected */
2588
6011
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2589
        if (!av_filename_number_test(oc->url)) {
2590
            print_error(oc->url, AVERROR(EINVAL));
2591
            exit_program(1);
2592
        }
2593
    }
2594
2595

6011
    if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2596
        av_log(NULL, AV_LOG_ERROR,
2597
               "No input streams but output needs an input stream\n");
2598
        exit_program(1);
2599
    }
2600
2601
6011
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2602
        /* test if it already exists to avoid losing precious files */
2603
5957
        assert_file_overwrite(filename);
2604
2605
        /* open the file */
2606
5957
        if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2607
5957
                              &oc->interrupt_callback,
2608
                              &of->opts)) < 0) {
2609
            print_error(filename, err);
2610
            exit_program(1);
2611
        }
2612

54
    } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2613
        assert_file_overwrite(filename);
2614
2615
6011
    if (o->mux_preload) {
2616
        av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2617
    }
2618
6011
    oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2619
2620
    /* copy metadata */
2621
6016
    for (i = 0; i < o->nb_metadata_map; i++) {
2622
        char *p;
2623
5
        int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2624
2625
5
        if (in_file_index >= nb_input_files) {
2626
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2627
            exit_program(1);
2628
        }
2629

8
        copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2630
                      in_file_index >= 0 ?
2631
3
                      input_files[in_file_index]->ctx : NULL, o);
2632
    }
2633
2634
    /* copy chapters */
2635
6011
    if (o->chapters_input_file >= nb_input_files) {
2636
6011
        if (o->chapters_input_file == INT_MAX) {
2637
            /* copy chapters from the first input file that has them*/
2638
6011
            o->chapters_input_file = -1;
2639
12035
            for (i = 0; i < nb_input_files; i++)
2640
6039
                if (input_files[i]->ctx->nb_chapters) {
2641
15
                    o->chapters_input_file = i;
2642
15
                    break;
2643
                }
2644
        } else {
2645
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2646
                   o->chapters_input_file);
2647
            exit_program(1);
2648
        }
2649
    }
2650
6011
    if (o->chapters_input_file >= 0)
2651
15
        copy_chapters(input_files[o->chapters_input_file], of,
2652
15
                      !o->metadata_chapters_manual);
2653
2654
    /* copy global metadata by default */
2655

6011
    if (!o->metadata_global_manual && nb_input_files){
2656
5967
        av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2657
                     AV_DICT_DONT_OVERWRITE);
2658
5967
        if(o->recording_time != INT64_MAX)
2659
131
            av_dict_set(&oc->metadata, "duration", NULL, 0);
2660
5967
        av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2661
5967
        av_dict_set(&oc->metadata, "company_name", NULL, 0);
2662
5967
        av_dict_set(&oc->metadata, "product_name", NULL, 0);
2663
5967
        av_dict_set(&oc->metadata, "product_version", NULL, 0);
2664
    }
2665
6011
    if (!o->metadata_streams_manual)
2666
12200
        for (i = of->ost_index; i < nb_output_streams; i++) {
2667
            InputStream *ist;
2668
6190
            if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2669
84
                continue;
2670
6106
            ist = input_streams[output_streams[i]->source_index];
2671
6106
            av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2672
6106
            if (!output_streams[i]->stream_copy) {
2673
5760
                av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2674
            }
2675
        }
2676
2677
    /* process manually set programs */
2678
6011
    for (i = 0; i < o->nb_program; i++) {
2679
        const char *p = o->program[i].u.str;
2680
        int progid = i+1;
2681
        AVProgram *program;
2682
2683
        while(*p) {
2684
            const char *p2 = av_get_token(&p, ":");
2685
            const char *to_dealloc = p2;
2686
            char *key;
2687
            if (!p2)
2688
                break;
2689
2690
            if(*p) p++;
2691
2692
            key = av_get_token(&p2, "=");
2693
            if (!key || !*p2) {
2694
                av_freep(&to_dealloc);
2695
                av_freep(&key);
2696
                break;
2697
            }
2698
            p2++;
2699
2700
            if (!strcmp(key, "program_num"))
2701
                progid = strtol(p2, NULL, 0);
2702
            av_freep(&to_dealloc);
2703
            av_freep(&key);
2704
        }
2705
2706
        program = av_new_program(oc, progid);
2707
2708
        p = o->program[i].u.str;
2709
        while(*p) {
2710
            const char *p2 = av_get_token(&p, ":");
2711
            const char *to_dealloc = p2;
2712
            char *key;
2713
            if (!p2)
2714
                break;
2715
            if(*p) p++;
2716
2717
            key = av_get_token(&p2, "=");
2718
            if (!key) {
2719
                av_log(NULL, AV_LOG_FATAL,
2720
                       "No '=' character in program string %s.\n",
2721
                       p2);
2722
                exit_program(1);
2723
            }
2724
            if (!*p2)
2725
                exit_program(1);
2726
            p2++;
2727
2728
            if (!strcmp(key, "title")) {
2729
                av_dict_set(&program->metadata, "title", p2, 0);
2730
            } else if (!strcmp(key, "program_num")) {
2731
            } else if (!strcmp(key, "st")) {
2732
                int st_num = strtol(p2, NULL, 0);
2733
                av_program_add_stream_index(oc, progid, st_num);
2734
            } else {
2735
                av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2736
                exit_program(1);
2737
            }
2738
            av_freep(&to_dealloc);
2739
            av_freep(&key);
2740
        }
2741
    }
2742
2743
    /* process manually set metadata */
2744
6172
    for (i = 0; i < o->nb_metadata; i++) {
2745
        AVDictionary **m;
2746
        char type, *val;
2747
        const char *stream_spec;
2748
161
        int index = 0, j, ret = 0;
2749
2750
161
        val = strchr(o->metadata[i].u.str, '=');
2751
161
        if (!val) {
2752
            av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2753
                   o->metadata[i].u.str);
2754
            exit_program(1);
2755
        }
2756
161
        *val++ = 0;
2757
2758
161
        parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2759
161
        if (type == 's') {
2760
76
            for (j = 0; j < oc->nb_streams; j++) {
2761
58
                ost = output_streams[nb_output_streams - oc->nb_streams + j];
2762
58
                if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2763
18
                    if (!strcmp(o->metadata[i].u.str, "rotate")) {
2764
                        char *tail;
2765
1
                        double theta = av_strtod(val, &tail);
2766
1
                        if (!*tail) {
2767
1
                            ost->rotate_overridden = 1;
2768
1
                            ost->rotate_override_value = theta;
2769
                        }
2770
                    } else {
2771
17
                        av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2772
                    }
2773
40
                } else if (ret < 0)
2774
                    exit_program(1);
2775
            }
2776
        }
2777
        else {
2778

143
            switch (type) {
2779
139
            case 'g':
2780
139
                m = &oc->metadata;
2781
139
                break;
2782
4
            case 'c':
2783

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