GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/fftools/ffmpeg_opt.c Lines: 1144 1991 57.5 %
Date: 2019-11-18 18:00:01 Branches: 807 1692 47.7 %

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 MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48
{\
49
    int i, ret;\
50
    for (i = 0; i < o->nb_ ## name; i++) {\
51
        char *spec = o->name[i].specifier;\
52
        if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
53
            outvar = o->name[i].u.type;\
54
        else if (ret < 0)\
55
            exit_program(1);\
56
    }\
57
}
58
59
#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60
{\
61
    int i;\
62
    for (i = 0; i < o->nb_ ## name; i++) {\
63
        char *spec = o->name[i].specifier;\
64
        if (!strcmp(spec, mediatype))\
65
            outvar = o->name[i].u.type;\
66
    }\
67
}
68
69
const HWAccel hwaccels[] = {
70
#if CONFIG_VIDEOTOOLBOX
71
    { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
72
#endif
73
#if CONFIG_LIBMFX
74
    { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV },
75
#endif
76
#if CONFIG_CUVID
77
    { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
78
#endif
79
    { 0 },
80
};
81
AVBufferRef *hw_device_ctx;
82
HWDevice *filter_hw_device;
83
84
char *vstats_filename;
85
char *sdp_filename;
86
87
float audio_drift_threshold = 0.1;
88
float dts_delta_threshold   = 10;
89
float dts_error_threshold   = 3600*30;
90
91
int audio_volume      = 256;
92
int audio_sync_method = 0;
93
int video_sync_method = VSYNC_AUTO;
94
float frame_drop_threshold = 0;
95
int do_deinterlace    = 0;
96
int do_benchmark      = 0;
97
int do_benchmark_all  = 0;
98
int do_hex_dump       = 0;
99
int do_pkt_dump       = 0;
100
int copy_ts           = 0;
101
int start_at_zero     = 0;
102
int copy_tb           = -1;
103
int debug_ts          = 0;
104
int exit_on_error     = 0;
105
int abort_on_flags    = 0;
106
int print_stats       = -1;
107
int qp_hist           = 0;
108
int stdin_interaction = 1;
109
int frame_bits_per_raw_sample = 0;
110
float max_error_rate  = 2.0/3;
111
int filter_nbthreads = 0;
112
int filter_complex_nbthreads = 0;
113
int vstats_version = 2;
114
115
116
static int intra_only         = 0;
117
static int file_overwrite     = 0;
118
static int no_file_overwrite  = 0;
119
static int do_psnr            = 0;
120
static int input_sync;
121
static int input_stream_potentially_available = 0;
122
static int ignore_unknown_streams = 0;
123
static int copy_unknown_streams = 0;
124
static int find_stream_info = 1;
125
126
11691
static void uninit_options(OptionsContext *o)
127
{
128
11691
    const OptionDef *po = options;
129
    int i;
130
131
    /* all OPT_SPEC and OPT_STRING can be freed in generic way */
132
2080998
    while (po->name) {
133
2069307
        void *dst = (uint8_t*)o + po->u.off;
134
135
2069307
        if (po->flags & OPT_SPEC) {
136
537786
            SpecifierOpt **so = dst;
137
537786
            int i, *count = (int*)(so + 1);
138
561265
            for (i = 0; i < *count; i++) {
139
23479
                av_freep(&(*so)[i].specifier);
140
23479
                if (po->flags & OPT_STRING)
141
18951
                    av_freep(&(*so)[i].u.str);
142
            }
143
537786
            av_freep(so);
144
537786
            *count = 0;
145

1531521
        } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
146
11691
            av_freep(dst);
147
2069307
        po++;
148
    }
149
150
11756
    for (i = 0; i < o->nb_stream_maps; i++)
151
65
        av_freep(&o->stream_maps[i].linklabel);
152
11691
    av_freep(&o->stream_maps);
153
11691
    av_freep(&o->audio_channel_maps);
154
11691
    av_freep(&o->streamid_map);
155
11691
    av_freep(&o->attachments);
156
11691
}
157
158
11692
static void init_options(OptionsContext *o)
159
{
160
11692
    memset(o, 0, sizeof(*o));
161
162
11692
    o->stop_time = INT64_MAX;
163
11692
    o->mux_max_delay  = 0.7;
164
11692
    o->start_time     = AV_NOPTS_VALUE;
165
11692
    o->start_time_eof = AV_NOPTS_VALUE;
166
11692
    o->recording_time = INT64_MAX;
167
11692
    o->limit_filesize = UINT64_MAX;
168
11692
    o->chapters_input_file = INT_MAX;
169
11692
    o->accurate_seek  = 1;
170
11692
}
171
172
static int show_hwaccels(void *optctx, const char *opt, const char *arg)
173
{
174
    enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
175
    int i;
176
177
    printf("Hardware acceleration methods:\n");
178
    while ((type = av_hwdevice_iterate_types(type)) !=
179
           AV_HWDEVICE_TYPE_NONE)
180
        printf("%s\n", av_hwdevice_get_type_name(type));
181
    for (i = 0; hwaccels[i].name; i++)
182
        printf("%s\n", hwaccels[i].name);
183
    printf("\n");
184
    return 0;
185
}
186
187
/* return a copy of the input with the stream specifiers removed from the keys */
188
11691
static AVDictionary *strip_specifiers(AVDictionary *dict)
189
{
190
11691
    AVDictionaryEntry *e = NULL;
191
11691
    AVDictionary    *ret = NULL;
192
193
44054
    while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
194
32363
        char *p = strchr(e->key, ':');
195
196
32363
        if (p)
197
195
            *p = 0;
198
32363
        av_dict_set(&ret, e->key, e->value, 0);
199
32363
        if (p)
200
195
            *p = ':';
201
    }
202
11691
    return ret;
203
}
204
205
static int opt_abort_on(void *optctx, const char *opt, const char *arg)
206
{
207
    static const AVOption opts[] = {
208
        { "abort_on"        , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
209
        { "empty_output"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT     },    .unit = "flags" },
210
        { NULL },
211
    };
212
    static const AVClass class = {
213
        .class_name = "",
214
        .item_name  = av_default_item_name,
215
        .option     = opts,
216
        .version    = LIBAVUTIL_VERSION_INT,
217
    };
218
    const AVClass *pclass = &class;
219
220
    return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
221
}
222
223
static int opt_sameq(void *optctx, const char *opt, const char *arg)
224
{
225
    av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
226
           "If you are looking for an option to preserve the quality (which is not "
227
           "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
228
           opt, opt);
229
    return AVERROR(EINVAL);
230
}
231
232
static int opt_video_channel(void *optctx, const char *opt, const char *arg)
233
{
234
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
235
    return opt_default(optctx, "channel", arg);
236
}
237
238
static int opt_video_standard(void *optctx, const char *opt, const char *arg)
239
{
240
    av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
241
    return opt_default(optctx, "standard", arg);
242
}
243
244
11
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
245
{
246
11
    OptionsContext *o = optctx;
247
11
    return parse_option(o, "codec:a", arg, options);
248
}
249
250
4068
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
251
{
252
4068
    OptionsContext *o = optctx;
253
4068
    return parse_option(o, "codec:v", arg, options);
254
}
255
256
2
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
257
{
258
2
    OptionsContext *o = optctx;
259
2
    return parse_option(o, "codec:s", arg, options);
260
}
261
262
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
263
{
264
    OptionsContext *o = optctx;
265
    return parse_option(o, "codec:d", arg, options);
266
}
267
268
57
static int opt_map(void *optctx, const char *opt, const char *arg)
269
{
270
57
    OptionsContext *o = optctx;
271
57
    StreamMap *m = NULL;
272
57
    int i, negative = 0, file_idx, disabled = 0;
273
57
    int sync_file_idx = -1, sync_stream_idx = 0;
274
    char *p, *sync;
275
    char *map;
276
    char *allow_unused;
277
278
57
    if (*arg == '-') {
279
        negative = 1;
280
        arg++;
281
    }
282
57
    map = av_strdup(arg);
283
57
    if (!map)
284
        return AVERROR(ENOMEM);
285
286
    /* parse sync stream first, just pick first matching stream */
287
57
    if (sync = strchr(map, ',')) {
288
        *sync = 0;
289
        sync_file_idx = strtol(sync + 1, &sync, 0);
290
        if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
291
            av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
292
            exit_program(1);
293
        }
294
        if (*sync)
295
            sync++;
296
        for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
297
            if (check_stream_specifier(input_files[sync_file_idx]->ctx,
298
                                       input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
299
                sync_stream_idx = i;
300
                break;
301
            }
302
        if (i == input_files[sync_file_idx]->nb_streams) {
303
            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
304
                                       "match any streams.\n", arg);
305
            exit_program(1);
306
        }
307
        if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
308
            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
309
                                       "stream.\n", arg);
310
            exit_program(1);
311
        }
312
    }
313
314
315
57
    if (map[0] == '[') {
316
        /* this mapping refers to lavfi output */
317
3
        const char *c = map + 1;
318
3
        GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
319
3
        m = &o->stream_maps[o->nb_stream_maps - 1];
320
3
        m->linklabel = av_get_token(&c, "]");
321
3
        if (!m->linklabel) {
322
            av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
323
            exit_program(1);
324
        }
325
    } else {
326
54
        if (allow_unused = strchr(map, '?'))
327
            *allow_unused = 0;
328
54
        file_idx = strtol(map, &p, 0);
329

54
        if (file_idx >= nb_input_files || file_idx < 0) {
330
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
331
            exit_program(1);
332
        }
333
54
        if (negative)
334
            /* disable some already defined maps */
335
            for (i = 0; i < o->nb_stream_maps; i++) {
336
                m = &o->stream_maps[i];
337
                if (file_idx == m->file_index &&
338
                    check_stream_specifier(input_files[m->file_index]->ctx,
339
                                           input_files[m->file_index]->ctx->streams[m->stream_index],
340
                                           *p == ':' ? p + 1 : p) > 0)
341
                    m->disabled = 1;
342
            }
343
        else
344
150
            for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
345
96
                if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
346
96
                            *p == ':' ? p + 1 : p) <= 0)
347
34
                    continue;
348
62
                if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
349
                    disabled = 1;
350
                    continue;
351
                }
352
62
                GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
353
62
                m = &o->stream_maps[o->nb_stream_maps - 1];
354
355
62
                m->file_index   = file_idx;
356
62
                m->stream_index = i;
357
358
62
                if (sync_file_idx >= 0) {
359
                    m->sync_file_index   = sync_file_idx;
360
                    m->sync_stream_index = sync_stream_idx;
361
                } else {
362
62
                    m->sync_file_index   = file_idx;
363
62
                    m->sync_stream_index = i;
364
                }
365
            }
366
    }
367
368
57
    if (!m) {
369
        if (allow_unused) {
370
            av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
371
        } else if (disabled) {
372
            av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
373
                                       "To ignore this, add a trailing '?' to the map.\n", arg);
374
            exit_program(1);
375
        } else {
376
            av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
377
                                       "To ignore this, add a trailing '?' to the map.\n", arg);
378
            exit_program(1);
379
        }
380
    }
381
382
57
    av_freep(&map);
383
57
    return 0;
384
}
385
386
1
static int opt_attach(void *optctx, const char *opt, const char *arg)
387
{
388
1
    OptionsContext *o = optctx;
389
1
    GROW_ARRAY(o->attachments, o->nb_attachments);
390
1
    o->attachments[o->nb_attachments - 1] = arg;
391
1
    return 0;
392
}
393
394
10
static int opt_map_channel(void *optctx, const char *opt, const char *arg)
395
{
396
10
    OptionsContext *o = optctx;
397
    int n;
398
    AVStream *st;
399
    AudioChannelMap *m;
400
    char *allow_unused;
401
    char *mapchan;
402
10
    mapchan = av_strdup(arg);
403
10
    if (!mapchan)
404
        return AVERROR(ENOMEM);
405
406
10
    GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
407
10
    m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
408
409
    /* muted channel syntax */
410
10
    n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
411

10
    if ((n == 1 || n == 3) && m->channel_idx == -1) {
412
1
        m->file_idx = m->stream_idx = -1;
413
1
        if (n == 1)
414
1
            m->ofile_idx = m->ostream_idx = -1;
415
1
        av_free(mapchan);
416
1
        return 0;
417
    }
418
419
    /* normal syntax */
420
9
    n = sscanf(arg, "%d.%d.%d:%d.%d",
421
               &m->file_idx,  &m->stream_idx, &m->channel_idx,
422
               &m->ofile_idx, &m->ostream_idx);
423
424

9
    if (n != 3 && n != 5) {
425
        av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
426
               "[file.stream.channel|-1][:syncfile:syncstream]\n");
427
        exit_program(1);
428
    }
429
430
9
    if (n != 5) // only file.stream.channel specified
431
9
        m->ofile_idx = m->ostream_idx = -1;
432
433
    /* check input */
434

9
    if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
435
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
436
               m->file_idx);
437
        exit_program(1);
438
    }
439
9
    if (m->stream_idx < 0 ||
440
9
        m->stream_idx >= input_files[m->file_idx]->nb_streams) {
441
        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
442
               m->file_idx, m->stream_idx);
443
        exit_program(1);
444
    }
445
9
    st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
446
9
    if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
447
        av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
448
               m->file_idx, m->stream_idx);
449
        exit_program(1);
450
    }
451
    /* allow trailing ? to map_channel */
452
9
    if (allow_unused = strchr(mapchan, '?'))
453
2
        *allow_unused = 0;
454

9
    if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
455
8
        input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
456
1
        if (allow_unused) {
457
1
            av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
458
                    m->file_idx, m->stream_idx, m->channel_idx);
459
        } else {
460
            av_log(NULL, AV_LOG_FATAL,  "mapchan: invalid audio channel #%d.%d.%d\n"
461
                    "To ignore this, add a trailing '?' to the map_channel.\n",
462
                    m->file_idx, m->stream_idx, m->channel_idx);
463
            exit_program(1);
464
        }
465
466
    }
467
9
    av_free(mapchan);
468
9
    return 0;
469
}
470
471
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
472
{
473
    av_free(sdp_filename);
474
    sdp_filename = av_strdup(arg);
475
    return 0;
476
}
477
478
#if CONFIG_VAAPI
479
static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
480
{
481
    HWDevice *dev;
482
    const char *prefix = "vaapi:";
483
    char *tmp;
484
    int err;
485
    tmp = av_asprintf("%s%s", prefix, arg);
486
    if (!tmp)
487
        return AVERROR(ENOMEM);
488
    err = hw_device_init_from_string(tmp, &dev);
489
    av_free(tmp);
490
    if (err < 0)
491
        return err;
492
    hw_device_ctx = av_buffer_ref(dev->device_ref);
493
    if (!hw_device_ctx)
494
        return AVERROR(ENOMEM);
495
    return 0;
496
}
497
#endif
498
499
static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
500
{
501
    if (!strcmp(arg, "list")) {
502
        enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
503
        printf("Supported hardware device types:\n");
504
        while ((type = av_hwdevice_iterate_types(type)) !=
505
               AV_HWDEVICE_TYPE_NONE)
506
            printf("%s\n", av_hwdevice_get_type_name(type));
507
        printf("\n");
508
        exit_program(0);
509
    } else {
510
        return hw_device_init_from_string(arg, NULL);
511
    }
512
}
513
514
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
515
{
516
    if (filter_hw_device) {
517
        av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
518
        return AVERROR(EINVAL);
519
    }
520
    filter_hw_device = hw_device_get_by_name(arg);
521
    if (!filter_hw_device) {
522
        av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
523
        return AVERROR(EINVAL);
524
    }
525
    return 0;
526
}
527
528
/**
529
 * Parse a metadata specifier passed as 'arg' parameter.
530
 * @param arg  metadata string to parse
531
 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
532
 * @param index for type c/p, chapter/program index is written here
533
 * @param stream_spec for type s, the stream specifier is written here
534
 */
535
149
static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
536
{
537
149
    if (*arg) {
538
29
        *type = *arg;
539

29
        switch (*arg) {
540
17
        case 'g':
541
17
            break;
542
12
        case 's':
543

12
            if (*(++arg) && *arg != ':') {
544
                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
545
                exit_program(1);
546
            }
547
12
            *stream_spec = *arg == ':' ? arg + 1 : "";
548
12
            break;
549
        case 'c':
550
        case 'p':
551
            if (*(++arg) == ':')
552
                *index = strtol(++arg, NULL, 0);
553
            break;
554
        default:
555
            av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
556
            exit_program(1);
557
        }
558
    } else
559
120
        *type = 'g';
560
149
}
561
562
5
static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
563
{
564
5
    AVDictionary **meta_in = NULL;
565
5
    AVDictionary **meta_out = NULL;
566
5
    int i, ret = 0;
567
    char type_in, type_out;
568
5
    const char *istream_spec = NULL, *ostream_spec = NULL;
569
5
    int idx_in = 0, idx_out = 0;
570
571
5
    parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
572
5
    parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
573
574
5
    if (!ic) {
575

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

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

2
        if (type_out == 'c' || !*outspec)
580
            o->metadata_chapters_manual = 1;
581
2
        return 0;
582
    }
583
584

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

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

3
    if (type_in == 'c' || type_out == 'c')
589
        o->metadata_chapters_manual = 1;
590
591
    /* ic is NULL when just disabling automatic mappings */
592
3
    if (!ic)
593
        return 0;
594
595
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
596
    if ((index) < 0 || (index) >= (nb_elems)) {\
597
        av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
598
                (desc), (index));\
599
        exit_program(1);\
600
    }
601
602
#define SET_DICT(type, meta, context, index)\
603
        switch (type) {\
604
        case 'g':\
605
            meta = &context->metadata;\
606
            break;\
607
        case 'c':\
608
            METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
609
            meta = &context->chapters[index]->metadata;\
610
            break;\
611
        case 'p':\
612
            METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
613
            meta = &context->programs[index]->metadata;\
614
            break;\
615
        case 's':\
616
            break; /* handled separately below */ \
617
        default: av_assert0(0);\
618
        }\
619
620



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



3
    SET_DICT(type_out, meta_out, oc, idx_out);
622
623
    /* for input streams choose first matching stream */
624
3
    if (type_in == 's') {
625
3
        for (i = 0; i < ic->nb_streams; i++) {
626
3
            if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
627
2
                meta_in = &ic->streams[i]->metadata;
628
2
                break;
629
1
            } else if (ret < 0)
630
                exit_program(1);
631
        }
632
2
        if (!meta_in) {
633
            av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
634
            exit_program(1);
635
        }
636
    }
637
638
3
    if (type_out == 's') {
639
8
        for (i = 0; i < oc->nb_streams; i++) {
640
6
            if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
641
2
                meta_out = &oc->streams[i]->metadata;
642
2
                av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
643
4
            } else if (ret < 0)
644
                exit_program(1);
645
        }
646
    } else
647
1
        av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
648
649
3
    return 0;
650
}
651
652
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
653
{
654
    OptionsContext *o = optctx;
655
    char buf[128];
656
    int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
657
    struct tm time = *gmtime((time_t*)&recording_timestamp);
658
    if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
659
        return -1;
660
    parse_option(o, "metadata", buf, options);
661
662
    av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
663
                                 "tag instead.\n", opt);
664
    return 0;
665
}
666
667
10016
static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
668
{
669
    const AVCodecDescriptor *desc;
670
10016
    const char *codec_string = encoder ? "encoder" : "decoder";
671
    AVCodec *codec;
672
673
10016
    codec = encoder ?
674
10016
        avcodec_find_encoder_by_name(name) :
675
6910
        avcodec_find_decoder_by_name(name);
676
677

10016
    if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
678
1
        codec = encoder ? avcodec_find_encoder(desc->id) :
679
                          avcodec_find_decoder(desc->id);
680
1
        if (codec)
681
1
            av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
682
                   codec_string, codec->name, desc->name);
683
    }
684
685
10016
    if (!codec) {
686
        av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
687
        exit_program(1);
688
    }
689
10016
    if (codec->type != type) {
690
        av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
691
        exit_program(1);
692
    }
693
10016
    return codec;
694
}
695
696
12260
static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
697
{
698
12260
    char *codec_name = NULL;
699
700

16884
    MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
701
12260
    if (codec_name) {
702
4618
        AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
703
4618
        st->codecpar->codec_id = codec->id;
704
4618
        return codec;
705
    } else
706
7642
        return avcodec_find_decoder(st->codecpar->codec_id);
707
}
708
709
/* Add all the streams from the given input file to the global
710
 * list of input streams. */
711
5861
static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
712
{
713
    int i, ret;
714
715
12038
    for (i = 0; i < ic->nb_streams; i++) {
716
6177
        AVStream *st = ic->streams[i];
717
6177
        AVCodecParameters *par = st->codecpar;
718
6177
        InputStream *ist = av_mallocz(sizeof(*ist));
719
6177
        char *framerate = NULL, *hwaccel_device = NULL;
720
6177
        const char *hwaccel = NULL;
721
6177
        char *hwaccel_output_format = NULL;
722
6177
        char *codec_tag = NULL;
723
        char *next;
724
6177
        char *discard_str = NULL;
725
6177
        const AVClass *cc = avcodec_get_class();
726
6177
        const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
727
728
6177
        if (!ist)
729
            exit_program(1);
730
731
6177
        GROW_ARRAY(input_streams, nb_input_streams);
732
6177
        input_streams[nb_input_streams - 1] = ist;
733
734
6177
        ist->st = st;
735
6177
        ist->file_index = nb_input_files;
736
6177
        ist->discard = 1;
737
6177
        st->discard  = AVDISCARD_ALL;
738
6177
        ist->nb_samples = 0;
739
6177
        ist->min_pts = INT64_MAX;
740
6177
        ist->max_pts = INT64_MIN;
741
742
6177
        ist->ts_scale = 1.0;
743

6177
        MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
744
745
6177
        ist->autorotate = 1;
746

6177
        MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
747
748

6179
        MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
749
6177
        if (codec_tag) {
750
2
            uint32_t tag = strtol(codec_tag, &next, 0);
751
2
            if (*next)
752
2
                tag = AV_RL32(codec_tag);
753
2
            st->codecpar->codec_tag = tag;
754
        }
755
756
6177
        ist->dec = choose_decoder(o, ic, st);
757
6177
        ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
758
759
6177
        ist->reinit_filters = -1;
760

6177
        MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
761
762

6177
        MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
763
6177
        ist->user_set_discard = AVDISCARD_NONE;
764
765

6177
        if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
766

6177
            (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
767

6177
            (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
768

6177
            (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
769
                ist->user_set_discard = AVDISCARD_ALL;
770
771

6177
        if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
772
            av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
773
                    discard_str);
774
            exit_program(1);
775
        }
776
777
6177
        ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
778
779
6177
        ist->dec_ctx = avcodec_alloc_context3(ist->dec);
780
6177
        if (!ist->dec_ctx) {
781
            av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
782
            exit_program(1);
783
        }
784
785
6177
        ret = avcodec_parameters_to_context(ist->dec_ctx, par);
786
6177
        if (ret < 0) {
787
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
788
            exit_program(1);
789
        }
790
791
6177
        if (o->bitexact)
792
84
            ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
793
794

6177
        switch (par->codec_type) {
795
4757
        case AVMEDIA_TYPE_VIDEO:
796
4757
            if(!ist->dec)
797
                ist->dec = avcodec_find_decoder(par->codec_id);
798
#if FF_API_LOWRES
799
4757
            if (st->codec->lowres) {
800
1
                ist->dec_ctx->lowres = st->codec->lowres;
801
1
                ist->dec_ctx->width  = st->codec->width;
802
1
                ist->dec_ctx->height = st->codec->height;
803
1
                ist->dec_ctx->coded_width  = st->codec->coded_width;
804
1
                ist->dec_ctx->coded_height = st->codec->coded_height;
805
            }
806
#endif
807
808
            // avformat_find_stream_info() doesn't set this for us anymore.
809
4757
            ist->dec_ctx->framerate = st->avg_frame_rate;
810
811

4781
            MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
812

4757
            if (framerate && av_parse_video_rate(&ist->framerate,
813
                                                 framerate) < 0) {
814
                av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
815
                       framerate);
816
                exit_program(1);
817
            }
818
819
4757
            ist->top_field_first = -1;
820

4757
            MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
821
822

9279
            MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
823
4757
            if (hwaccel) {
824
                // The NVDEC hwaccels use a CUDA device, so remap the name here.
825
4522
                if (!strcmp(hwaccel, "nvdec"))
826
                    hwaccel = "cuda";
827
828
4522
                if (!strcmp(hwaccel, "none"))
829
4522
                    ist->hwaccel_id = HWACCEL_NONE;
830
                else if (!strcmp(hwaccel, "auto"))
831
                    ist->hwaccel_id = HWACCEL_AUTO;
832
                else {
833
                    enum AVHWDeviceType type;
834
                    int i;
835
                    for (i = 0; hwaccels[i].name; i++) {
836
                        if (!strcmp(hwaccels[i].name, hwaccel)) {
837
                            ist->hwaccel_id = hwaccels[i].id;
838
                            break;
839
                        }
840
                    }
841
842
                    if (!ist->hwaccel_id) {
843
                        type = av_hwdevice_find_type_by_name(hwaccel);
844
                        if (type != AV_HWDEVICE_TYPE_NONE) {
845
                            ist->hwaccel_id = HWACCEL_GENERIC;
846
                            ist->hwaccel_device_type = type;
847
                        }
848
                    }
849
850
                    if (!ist->hwaccel_id) {
851
                        av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
852
                               hwaccel);
853
                        av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
854
                        type = AV_HWDEVICE_TYPE_NONE;
855
                        while ((type = av_hwdevice_iterate_types(type)) !=
856
                               AV_HWDEVICE_TYPE_NONE)
857
                            av_log(NULL, AV_LOG_FATAL, "%s ",
858
                                   av_hwdevice_get_type_name(type));
859
                        for (i = 0; hwaccels[i].name; i++)
860
                            av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
861
                        av_log(NULL, AV_LOG_FATAL, "\n");
862
                        exit_program(1);
863
                    }
864
                }
865
            }
866
867

4757
            MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
868
4757
            if (hwaccel_device) {
869
                ist->hwaccel_device = av_strdup(hwaccel_device);
870
                if (!ist->hwaccel_device)
871
                    exit_program(1);
872
            }
873
874

4757
            MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
875
                                 hwaccel_output_format, ic, st);
876
4757
            if (hwaccel_output_format) {
877
                ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
878
                if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
879
                    av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
880
                           "format: %s", hwaccel_output_format);
881
                }
882
            } else {
883
4757
                ist->hwaccel_output_format = AV_PIX_FMT_NONE;
884
            }
885
886
4757
            ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
887
888
4757
            break;
889
1329
        case AVMEDIA_TYPE_AUDIO:
890
1329
            ist->guess_layout_max = INT_MAX;
891

1333
            MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
892
1329
            guess_input_channel_layout(ist);
893
1329
            break;
894
90
        case AVMEDIA_TYPE_DATA:
895
        case AVMEDIA_TYPE_SUBTITLE: {
896
90
            char *canvas_size = NULL;
897
90
            if(!ist->dec)
898
48
                ist->dec = avcodec_find_decoder(par->codec_id);
899

90
            MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
900

90
            MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
901

90
            if (canvas_size &&
902
                av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
903
                av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
904
                exit_program(1);
905
            }
906
90
            break;
907
        }
908
1
        case AVMEDIA_TYPE_ATTACHMENT:
909
        case AVMEDIA_TYPE_UNKNOWN:
910
1
            break;
911
        default:
912
            abort();
913
        }
914
915
6177
        ret = avcodec_parameters_from_context(par, ist->dec_ctx);
916
6177
        if (ret < 0) {
917
            av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
918
            exit_program(1);
919
        }
920
    }
921
5861
}
922
923
5777
static void assert_file_overwrite(const char *filename)
924
{
925
5777
    const char *proto_name = avio_find_protocol_name(filename);
926
927

5777
    if (file_overwrite && no_file_overwrite) {
928
        fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
929
        exit_program(1);
930
    }
931
932
5777
    if (!file_overwrite) {
933

4340
        if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
934
            if (stdin_interaction && !no_file_overwrite) {
935
                fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
936
                fflush(stderr);
937
                term_exit();
938
                signal(SIGINT, SIG_DFL);
939
                if (!read_yesno()) {
940
                    av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
941
                    exit_program(1);
942
                }
943
                term_init();
944
            }
945
            else {
946
                av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
947
                exit_program(1);
948
            }
949
        }
950
    }
951
952

5777
    if (proto_name && !strcmp(proto_name, "file")) {
953
3157
        for (int i = 0; i < nb_input_files; i++) {
954
1599
             InputFile *file = input_files[i];
955
1599
             if (file->ctx->iformat->flags & AVFMT_NOFILE)
956
108
                 continue;
957
1491
             if (!strcmp(filename, file->ctx->url)) {
958
                 av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
959
                 av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
960
                 exit_program(1);
961
             }
962
        }
963
    }
964
5777
}
965
966
static void dump_attachment(AVStream *st, const char *filename)
967
{
968
    int ret;
969
    AVIOContext *out = NULL;
970
    AVDictionaryEntry *e;
971
972
    if (!st->codecpar->extradata_size) {
973
        av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
974
               nb_input_files - 1, st->index);
975
        return;
976
    }
977
    if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
978
        filename = e->value;
979
    if (!*filename) {
980
        av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
981
               "in stream #%d:%d.\n", nb_input_files - 1, st->index);
982
        exit_program(1);
983
    }
984
985
    assert_file_overwrite(filename);
986
987
    if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
988
        av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
989
               filename);
990
        exit_program(1);
991
    }
992
993
    avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
994
    avio_flush(out);
995
    avio_close(out);
996
}
997
998
5862
static int open_input_file(OptionsContext *o, const char *filename)
999
{
1000
    InputFile *f;
1001
    AVFormatContext *ic;
1002
5862
    AVInputFormat *file_iformat = NULL;
1003
    int err, i, ret;
1004
    int64_t timestamp;
1005
5862
    AVDictionary *unused_opts = NULL;
1006
5862
    AVDictionaryEntry *e = NULL;
1007
5862
    char *   video_codec_name = NULL;
1008
5862
    char *   audio_codec_name = NULL;
1009
5862
    char *subtitle_codec_name = NULL;
1010
5862
    char *    data_codec_name = NULL;
1011
5862
    int scan_all_pmts_set = 0;
1012
1013

5862
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1014
        o->stop_time = INT64_MAX;
1015
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1016
    }
1017
1018

5862
    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1019
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1020
        if (o->stop_time <= start_time) {
1021
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1022
            exit_program(1);
1023
        } else {
1024
            o->recording_time = o->stop_time - start_time;
1025
        }
1026
    }
1027
1028
5862
    if (o->format) {
1029
2813
        if (!(file_iformat = av_find_input_format(o->format))) {
1030
            av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1031
            exit_program(1);
1032
        }
1033
    }
1034
1035
5862
    if (!strcmp(filename, "-"))
1036
        filename = "pipe:";
1037
1038
11724
    stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1039
5862
                         strcmp(filename, "/dev/stdin");
1040
1041
    /* get default parameters from command line */
1042
5862
    ic = avformat_alloc_context();
1043
5862
    if (!ic) {
1044
        print_error(filename, AVERROR(ENOMEM));
1045
        exit_program(1);
1046
    }
1047
5862
    if (o->nb_audio_sample_rate) {
1048
63
        av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1049
    }
1050
5862
    if (o->nb_audio_channels) {
1051
        /* because we set audio_channels based on both the "ac" and
1052
         * "channel_layout" options, we need to check that the specified
1053
         * demuxer actually has the "channels" option before setting it */
1054

18
        if (file_iformat && file_iformat->priv_class &&
1055
9
            av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1056
                        AV_OPT_SEARCH_FAKE_OBJ)) {
1057
9
            av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1058
        }
1059
    }
1060
5862
    if (o->nb_frame_rates) {
1061
        /* set the format-level framerate option;
1062
         * this is important for video grabbers, e.g. x11 */
1063

48
        if (file_iformat && file_iformat->priv_class &&
1064
24
            av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1065
                        AV_OPT_SEARCH_FAKE_OBJ)) {
1066
24
            av_dict_set(&o->g->format_opts, "framerate",
1067
24
                        o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1068
        }
1069
    }
1070
5862
    if (o->nb_frame_sizes) {
1071
492
        av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1072
    }
1073
5862
    if (o->nb_frame_pix_fmts)
1074
497
        av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1075
1076

8171
    MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
1077

8171
    MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
1078

8171
    MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1079

8171
    MATCH_PER_TYPE_OPT(codec_names, str,     data_codec_name, ic, "d");
1080
1081
5862
    if (video_codec_name)
1082
2276
        ic->video_codec    = find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
1083
5862
    if (audio_codec_name)
1084
16
        ic->audio_codec    = find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
1085
5862
    if (subtitle_codec_name)
1086
        ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1087
5862
    if (data_codec_name)
1088
        ic->data_codec     = find_codec_or_die(data_codec_name    , AVMEDIA_TYPE_DATA    , 0);
1089
1090
5862
    ic->video_codec_id     = video_codec_name    ? ic->video_codec->id    : AV_CODEC_ID_NONE;
1091
5862
    ic->audio_codec_id     = audio_codec_name    ? ic->audio_codec->id    : AV_CODEC_ID_NONE;
1092
5862
    ic->subtitle_codec_id  = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1093
5862
    ic->data_codec_id      = data_codec_name     ? ic->data_codec->id     : AV_CODEC_ID_NONE;
1094
1095
5862
    ic->flags |= AVFMT_FLAG_NONBLOCK;
1096
5862
    if (o->bitexact)
1097
75
        ic->flags |= AVFMT_FLAG_BITEXACT;
1098
5862
    ic->interrupt_callback = int_cb;
1099
1100
5862
    if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1101
5862
        av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1102
5862
        scan_all_pmts_set = 1;
1103
    }
1104
    /* open the input file with generic avformat function */
1105
5862
    err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1106
5862
    if (err < 0) {
1107
1
        print_error(filename, err);
1108
1
        if (err == AVERROR_PROTOCOL_NOT_FOUND)
1109
            av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1110
1
        exit_program(1);
1111
    }
1112
5861
    if (scan_all_pmts_set)
1113
5861
        av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1114
5861
    remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1115
5861
    assert_avoptions(o->g->format_opts);
1116
1117
    /* apply forced codec ids */
1118
11944
    for (i = 0; i < ic->nb_streams; i++)
1119
6083
        choose_decoder(o, ic, ic->streams[i]);
1120
1121
5861
    if (find_stream_info) {
1122
5861
        AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1123
5861
        int orig_nb_streams = ic->nb_streams;
1124
1125
        /* If not enough info to get the stream parameters, we decode the
1126
           first frames to get it. (used in mpeg case for example) */
1127
5861
        ret = avformat_find_stream_info(ic, opts);
1128
1129
11944
        for (i = 0; i < orig_nb_streams; i++)
1130
6083
            av_dict_free(&opts[i]);
1131
5861
        av_freep(&opts);
1132
1133
5861
        if (ret < 0) {
1134
            av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1135
            if (ic->nb_streams == 0) {
1136
                avformat_close_input(&ic);
1137
                exit_program(1);
1138
            }
1139
        }
1140
    }
1141
1142

5861
    if (o->start_time != AV_NOPTS_VALUE && o->start_time_eof != AV_NOPTS_VALUE) {
1143
        av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1144
        o->start_time_eof = AV_NOPTS_VALUE;
1145
    }
1146
1147
5861
    if (o->start_time_eof != AV_NOPTS_VALUE) {
1148
        if (o->start_time_eof >= 0) {
1149
            av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1150
            exit_program(1);
1151
        }
1152
        if (ic->duration > 0) {
1153
            o->start_time = o->start_time_eof + ic->duration;
1154
            if (o->start_time < 0) {
1155
                av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1156
                o->start_time = AV_NOPTS_VALUE;
1157
            }
1158
        } else
1159
            av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1160
    }
1161
5861
    timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1162
    /* add the stream start time */
1163

5861
    if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1164
4405
        timestamp += ic->start_time;
1165
1166
    /* if seeking requested, we execute it */
1167
5861
    if (o->start_time != AV_NOPTS_VALUE) {
1168
21
        int64_t seek_timestamp = timestamp;
1169
1170
21
        if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1171
21
            int dts_heuristic = 0;
1172
42
            for (i=0; i<ic->nb_streams; i++) {
1173
21
                const AVCodecParameters *par = ic->streams[i]->codecpar;
1174
21
                if (par->video_delay) {
1175
                    dts_heuristic = 1;
1176
                    break;
1177
                }
1178
            }
1179
21
            if (dts_heuristic) {
1180
                seek_timestamp -= 3*AV_TIME_BASE / 23;
1181
            }
1182
        }
1183
21
        ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1184
21
        if (ret < 0) {
1185
1
            av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1186
1
                   filename, (double)timestamp / AV_TIME_BASE);
1187
        }
1188
    }
1189
1190
    /* update the current parameters so that they match the one of the input stream */
1191
5861
    add_input_streams(o, ic);
1192
1193
    /* dump the file content */
1194
5861
    av_dump_format(ic, nb_input_files, filename, 0);
1195
1196
5861
    GROW_ARRAY(input_files, nb_input_files);
1197
5861
    f = av_mallocz(sizeof(*f));
1198
5861
    if (!f)
1199
        exit_program(1);
1200
5861
    input_files[nb_input_files - 1] = f;
1201
1202
5861
    f->ctx        = ic;
1203
5861
    f->ist_index  = nb_input_streams - ic->nb_streams;
1204
5861
    f->start_time = o->start_time;
1205
5861
    f->recording_time = o->recording_time;
1206
5861
    f->input_ts_offset = o->input_ts_offset;
1207

5861
    f->ts_offset  = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1208
5861
    f->nb_streams = ic->nb_streams;
1209
5861
    f->rate_emu   = o->rate_emu;
1210
5861
    f->accurate_seek = o->accurate_seek;
1211
5861
    f->loop = o->loop;
1212
5861
    f->duration = 0;
1213
5861
    f->time_base = (AVRational){ 1, 1 };
1214
#if HAVE_THREADS
1215
5861
    f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1216
#endif
1217
1218
    /* check if all codec options have been used */
1219
5861
    unused_opts = strip_specifiers(o->g->codec_opts);
1220
12038
    for (i = f->ist_index; i < nb_input_streams; i++) {
1221
6177
        e = NULL;
1222
25131
        while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1223
                                AV_DICT_IGNORE_SUFFIX)))
1224
18954
            av_dict_set(&unused_opts, e->key, NULL, 0);
1225
    }
1226
1227
5861
    e = NULL;
1228
6111
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1229
250
        const AVClass *class = avcodec_get_class();
1230
250
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1231
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1232
250
        const AVClass *fclass = avformat_get_class();
1233
250
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1234
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1235

250
        if (!option || foption)
1236
            continue;
1237
1238
1239
250
        if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1240
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1241
                   "input file #%d (%s) is not a decoding option.\n", e->key,
1242
                   option->help ? option->help : "", nb_input_files - 1,
1243
                   filename);
1244
            exit_program(1);
1245
        }
1246
1247
250
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1248
               "input file #%d (%s) has not been used for any stream. The most "
1249
               "likely reason is either wrong type (e.g. a video option with "
1250
               "no video streams) or that it is a private option of some decoder "
1251
               "which was not actually used for any stream.\n", e->key,
1252
250
               option->help ? option->help : "", nb_input_files - 1, filename);
1253
    }
1254
5861
    av_dict_free(&unused_opts);
1255
1256
5861
    for (i = 0; i < o->nb_dump_attachment; i++) {
1257
        int j;
1258
1259
        for (j = 0; j < ic->nb_streams; j++) {
1260
            AVStream *st = ic->streams[j];
1261
1262
            if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1263
                dump_attachment(st, o->dump_attachment[i].u.str);
1264
        }
1265
    }
1266
1267
5861
    input_stream_potentially_available = 1;
1268
1269
5861
    return 0;
1270
}
1271
1272
static uint8_t *get_line(AVIOContext *s)
1273
{
1274
    AVIOContext *line;
1275
    uint8_t *buf;
1276
    char c;
1277
1278
    if (avio_open_dyn_buf(&line) < 0) {
1279
        av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1280
        exit_program(1);
1281
    }
1282
1283
    while ((c = avio_r8(s)) && c != '\n')
1284
        avio_w8(line, c);
1285
    avio_w8(line, 0);
1286
    avio_close_dyn_buf(line, &buf);
1287
1288
    return buf;
1289
}
1290
1291
static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1292
{
1293
    int i, ret = -1;
1294
    char filename[1000];
1295
    const char *base[3] = { getenv("AVCONV_DATADIR"),
1296
                            getenv("HOME"),
1297
                            AVCONV_DATADIR,
1298
                            };
1299
1300
    for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1301
        if (!base[i])
1302
            continue;
1303
        if (codec_name) {
1304
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1305
                     i != 1 ? "" : "/.avconv", codec_name, preset_name);
1306
            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1307
        }
1308
        if (ret < 0) {
1309
            snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1310
                     i != 1 ? "" : "/.avconv", preset_name);
1311
            ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1312
        }
1313
    }
1314
    return ret;
1315
}
1316
1317
5971
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1318
{
1319
5971
    enum AVMediaType type = ost->st->codecpar->codec_type;
1320
5971
    char *codec_name = NULL;
1321
1322

5971
    if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1323

9440
        MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1324
5960
        if (!codec_name) {
1325
5212
            ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1326
2606
                                                         NULL, ost->st->codecpar->codec_type);
1327
2606
            ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1328
2606
            if (!ost->enc) {
1329
                av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1330
                       "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1331
                       "probably disabled. Please choose an encoder manually.\n",
1332
                       ost->file_index, ost->index, s->oformat->name,
1333
                       avcodec_get_name(ost->st->codecpar->codec_id));
1334
                return AVERROR_ENCODER_NOT_FOUND;
1335
            }
1336
3354
        } else if (!strcmp(codec_name, "copy"))
1337
248
            ost->stream_copy = 1;
1338
        else {
1339
3106
            ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1340
3106
            ost->st->codecpar->codec_id = ost->enc->id;
1341
        }
1342
5960
        ost->encoding_needed = !ost->stream_copy;
1343
    } else {
1344
        /* no encoding supported for other media types */
1345
11
        ost->stream_copy     = 1;
1346
11
        ost->encoding_needed = 0;
1347
    }
1348
1349
5971
    return 0;
1350
}
1351
1352
5971
static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1353
{
1354
    OutputStream *ost;
1355
5971
    AVStream *st = avformat_new_stream(oc, NULL);
1356
5971
    int idx      = oc->nb_streams - 1, ret = 0;
1357
5971
    const char *bsfs = NULL, *time_base = NULL;
1358
5971
    char *next, *codec_tag = NULL;
1359
5971
    double qscale = -1;
1360
    int i;
1361
1362
5971
    if (!st) {
1363
        av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1364
        exit_program(1);
1365
    }
1366
1367
5971
    if (oc->nb_streams - 1 < o->nb_streamid_map)
1368
        st->id = o->streamid_map[oc->nb_streams - 1];
1369
1370
5971
    GROW_ARRAY(output_streams, nb_output_streams);
1371
5971
    if (!(ost = av_mallocz(sizeof(*ost))))
1372
        exit_program(1);
1373
5971
    output_streams[nb_output_streams - 1] = ost;
1374
1375
5971
    ost->file_index = nb_output_files - 1;
1376
5971
    ost->index      = idx;
1377
5971
    ost->st         = st;
1378
5971
    ost->forced_kf_ref_pts = AV_NOPTS_VALUE;
1379
5971
    st->codecpar->codec_type = type;
1380
1381
5971
    ret = choose_encoder(o, oc, ost);
1382
5971
    if (ret < 0) {
1383
        av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1384
               "%d:%d\n", ost->file_index, ost->index);
1385
        exit_program(1);
1386
    }
1387
1388
5971
    ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1389
5971
    if (!ost->enc_ctx) {
1390
        av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1391
        exit_program(1);
1392
    }
1393
5971
    ost->enc_ctx->codec_type = type;
1394
1395
5971
    ost->ref_par = avcodec_parameters_alloc();
1396
5971
    if (!ost->ref_par) {
1397
        av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1398
        exit_program(1);
1399
    }
1400
1401
5971
    if (ost->enc) {
1402
5712
        AVIOContext *s = NULL;
1403
5712
        char *buf = NULL, *arg = NULL, *preset = NULL;
1404
1405
5712
        ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1406
1407

5712
        MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1408

5712
        if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1409
            do  {
1410
                buf = get_line(s);
1411
                if (!buf[0] || buf[0] == '#') {
1412
                    av_free(buf);
1413
                    continue;
1414
                }
1415
                if (!(arg = strchr(buf, '='))) {
1416
                    av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1417
                    exit_program(1);
1418
                }
1419
                *arg++ = 0;
1420
                av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1421
                av_free(buf);
1422
            } while (!s->eof_reached);
1423
            avio_closep(&s);
1424
        }
1425
5712
        if (ret) {
1426
            av_log(NULL, AV_LOG_FATAL,
1427
                   "Preset %s specified for stream %d:%d, but could not be opened.\n",
1428
                   preset, ost->file_index, ost->index);
1429
            exit_program(1);
1430
        }
1431
    } else {
1432
259
        ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1433
    }
1434
1435
1436
5971
    if (o->bitexact)
1437
1653
        ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1438
1439

5972
    MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1440
5971
    if (time_base) {
1441
        AVRational q;
1442
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1443

1
            q.num <= 0 || q.den <= 0) {
1444
            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1445
            exit_program(1);
1446
        }
1447
1
        st->time_base = q;
1448
    }
1449
1450

5971
    MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1451
5971
    if (time_base) {
1452
        AVRational q;
1453
1
        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1454
1
            q.den <= 0) {
1455
            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1456
            exit_program(1);
1457
        }
1458
1
        ost->enc_timebase = q;
1459
    }
1460
1461
5971
    ost->max_frames = INT64_MAX;
1462

10124
    MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1463
10118
    for (i = 0; i<o->nb_max_frames; i++) {
1464
4153
        char *p = o->max_frames[i].specifier;
1465

4153
        if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1466
6
            av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1467
6
            break;
1468
        }
1469
    }
1470
1471
5971
    ost->copy_prior_start = -1;
1472

5971
    MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1473
1474

6039
    MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1475

6039
    while (bsfs && *bsfs) {
1476
        const AVBitStreamFilter *filter;
1477
        char *bsf, *bsf_options_str, *bsf_name;
1478
1479
68
        bsf = av_get_token(&bsfs, ",");
1480
68
        if (!bsf)
1481
            exit_program(1);
1482
68
        bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1483
68
        if (!bsf_name)
1484
            exit_program(1);
1485
1486
68
        filter = av_bsf_get_by_name(bsf_name);
1487
68
        if (!filter) {
1488
            av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1489
            exit_program(1);
1490
        }
1491
1492
136
        ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1493
68
                                        ost->nb_bitstream_filters + 1,
1494
                                        sizeof(*ost->bsf_ctx));
1495
68
        if (!ost->bsf_ctx)
1496
            exit_program(1);
1497
1498
68
        ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1499
68
        if (ret < 0) {
1500
            av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1501
            exit_program(1);
1502
        }
1503
1504
68
        ost->nb_bitstream_filters++;
1505
1506

68
        if (bsf_options_str && filter->priv_class) {
1507
10
            const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1508
10
            const char * shorthand[2] = {NULL};
1509
1510
10
            if (opt)
1511
10
                shorthand[0] = opt->name;
1512
1513
10
            ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1514
10
            if (ret < 0) {
1515
                av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1516
                exit_program(1);
1517
            }
1518
        }
1519
68
        av_freep(&bsf);
1520
1521
68
        if (*bsfs)
1522
            bsfs++;
1523
    }
1524
1525

5977
    MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1526
5971
    if (codec_tag) {
1527
6
        uint32_t tag = strtol(codec_tag, &next, 0);
1528
6
        if (*next)
1529
6
            tag = AV_RL32(codec_tag);
1530
6
        ost->st->codecpar->codec_tag =
1531
6
        ost->enc_ctx->codec_tag = tag;
1532
    }
1533
1534

6255
    MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1535
5971
    if (qscale >= 0) {
1536
232
        ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1537
232
        ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1538
    }
1539
1540

5971
    MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1541
5971
    ost->disposition = av_strdup(ost->disposition);
1542
1543
5971
    ost->max_muxing_queue_size = 128;
1544

5973
    MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1545
5971
    ost->max_muxing_queue_size *= sizeof(AVPacket);
1546
1547
5971
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1548
2279
        ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1549
1550
5971
    av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1551
1552
5971
    av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1553

5971
    if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1554
52
        av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1555
1556
5971
    av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1557
1558
5971
    ost->source_index = source_index;
1559
5971
    if (source_index >= 0) {
1560
5895
        ost->sync_ist = input_streams[source_index];
1561
5895
        input_streams[source_index]->discard = 0;
1562
5895
        input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1563
    }
1564
5971
    ost->last_mux_dts = AV_NOPTS_VALUE;
1565
1566
5971
    ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1567
5971
    if (!ost->muxing_queue)
1568
        exit_program(1);
1569
1570
5971
    return ost;
1571
}
1572
1573
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1574
{
1575
    int i;
1576
    const char *p = str;
1577
    for (i = 0;; i++) {
1578
        dest[i] = atoi(p);
1579
        if (i == 63)
1580
            break;
1581
        p = strchr(p, ',');
1582
        if (!p) {
1583
            av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1584
            exit_program(1);
1585
        }
1586
        p++;
1587
    }
1588
}
1589
1590
/* read file contents into a string */
1591
26
static uint8_t *read_file(const char *filename)
1592
{
1593
26
    AVIOContext *pb      = NULL;
1594
26
    AVIOContext *dyn_buf = NULL;
1595
26
    int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1596
    uint8_t buf[1024], *str;
1597
1598
26
    if (ret < 0) {
1599
        av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1600
        return NULL;
1601
    }
1602
1603
26
    ret = avio_open_dyn_buf(&dyn_buf);
1604
26
    if (ret < 0) {
1605
        avio_closep(&pb);
1606
        return NULL;
1607
    }
1608
52
    while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1609
26
        avio_write(dyn_buf, buf, ret);
1610
26
    avio_w8(dyn_buf, 0);
1611
26
    avio_closep(&pb);
1612
1613
26
    ret = avio_close_dyn_buf(dyn_buf, &str);
1614
26
    if (ret < 0)
1615
        return NULL;
1616
26
    return str;
1617
}
1618
1619
5682
static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1620
                             OutputStream *ost)
1621
{
1622
5682
    AVStream *st = ost->st;
1623
1624

5682
    if (ost->filters_script && ost->filters) {
1625
        av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1626
               "output stream #%d:%d.\n", nb_output_files, st->index);
1627
        exit_program(1);
1628
    }
1629
1630
5682
    if (ost->filters_script)
1631
4
        return read_file(ost->filters_script);
1632
5678
    else if (ost->filters)
1633
2554
        return av_strdup(ost->filters);
1634
1635
3124
    return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1636
                     "null" : "anull");
1637
}
1638
1639
242
static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1640
                                     const OutputStream *ost, enum AVMediaType type)
1641
{
1642

242
    if (ost->filters_script || ost->filters) {
1643
        av_log(NULL, AV_LOG_ERROR,
1644
               "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1645
               "Filtering and streamcopy cannot be used together.\n",
1646
               ost->filters ? "Filtergraph" : "Filtergraph script",
1647
               ost->filters ? ost->filters : ost->filters_script,
1648
               av_get_media_type_string(type), ost->file_index, ost->index);
1649
        exit_program(1);
1650
    }
1651
242
}
1652
1653
4735
static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1654
{
1655
    AVStream *st;
1656
    OutputStream *ost;
1657
    AVCodecContext *video_enc;
1658
4735
    char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1659
1660
4735
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1661
4735
    st  = ost->st;
1662
4735
    video_enc = ost->enc_ctx;
1663
1664

4756
    MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1665

4735
    if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1666
        av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1667
        exit_program(1);
1668
    }
1669

4735
    if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1670
        av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1671
1672

4735
    MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1673
4735
    if (frame_aspect_ratio) {
1674
        AVRational q;
1675
        if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1676
            q.num <= 0 || q.den <= 0) {
1677
            av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1678
            exit_program(1);
1679
        }
1680
        ost->frame_aspect_ratio = q;
1681
    }
1682
1683

4738
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1684

6899
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1685
4735
    if (o->nb_filters > 1)
1686
        av_log(NULL, AV_LOG_ERROR, "Only '-vf %s' read, ignoring remaining -vf options: Use ',' to separate filters\n", ost->filters);
1687
1688
4735
    if (!ost->stream_copy) {
1689
4590
        const char *p = NULL;
1690
4590
        char *frame_size = NULL;
1691
4590
        char *frame_pix_fmt = NULL;
1692
4590
        char *intra_matrix = NULL, *inter_matrix = NULL;
1693
4590
        char *chroma_intra_matrix = NULL;
1694
4590
        int do_pass = 0;
1695
        int i;
1696
1697

5202
        MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1698

4590
        if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1699
            av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1700
            exit_program(1);
1701
        }
1702
1703
4590
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1704

7885
        MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1705

4590
        if (frame_pix_fmt && *frame_pix_fmt == '+') {
1706
            ost->keep_pix_fmt = 1;
1707
            if (!*++frame_pix_fmt)
1708
                frame_pix_fmt = NULL;
1709
        }
1710

4590
        if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1711
            av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1712
            exit_program(1);
1713
        }
1714
4590
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1715
1716
4590
        if (intra_only)
1717
            video_enc->gop_size = 0;
1718

4590
        MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1719
4590
        if (intra_matrix) {
1720
            if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1721
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1722
                exit_program(1);
1723
            }
1724
            parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1725
        }
1726

4590
        MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1727
4590
        if (chroma_intra_matrix) {
1728
            uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1729
            if (!p) {
1730
                av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1731
                exit_program(1);
1732
            }
1733
            video_enc->chroma_intra_matrix = p;
1734
            parse_matrix_coeffs(p, chroma_intra_matrix);
1735
        }
1736

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

4590
        MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1746
4590
        for (i = 0; p; i++) {
1747
            int start, end, q;
1748
            int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1749
            if (e != 3) {
1750
                av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1751
                exit_program(1);
1752
            }
1753
            video_enc->rc_override =
1754
                av_realloc_array(video_enc->rc_override,
1755
                                 i + 1, sizeof(RcOverride));
1756
            if (!video_enc->rc_override) {
1757
                av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1758
                exit_program(1);
1759
            }
1760
            video_enc->rc_override[i].start_frame = start;
1761
            video_enc->rc_override[i].end_frame   = end;
1762
            if (q > 0) {
1763
                video_enc->rc_override[i].qscale         = q;
1764
                video_enc->rc_override[i].quality_factor = 1.0;
1765
            }
1766
            else {
1767
                video_enc->rc_override[i].qscale         = 0;
1768
                video_enc->rc_override[i].quality_factor = -q/100.0;
1769
            }
1770
            p = strchr(p, '/');
1771
            if (p) p++;
1772
        }
1773
4590
        video_enc->rc_override_count = i;
1774
1775
4590
        if (do_psnr)
1776
            video_enc->flags|= AV_CODEC_FLAG_PSNR;
1777
1778
        /* two pass mode */
1779

4590
        MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1780
4590
        if (do_pass) {
1781
            if (do_pass & 1) {
1782
                video_enc->flags |= AV_CODEC_FLAG_PASS1;
1783
                av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1784
            }
1785
            if (do_pass & 2) {
1786
                video_enc->flags |= AV_CODEC_FLAG_PASS2;
1787
                av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1788
            }
1789
        }
1790
1791

4590
        MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1792
4590
        if (ost->logfile_prefix &&
1793
            !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1794
            exit_program(1);
1795
1796
4590
        if (do_pass) {
1797
            char logfilename[1024];
1798
            FILE *f;
1799
1800
            snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1801
                     ost->logfile_prefix ? ost->logfile_prefix :
1802
                                           DEFAULT_PASS_LOGFILENAME_PREFIX,
1803
                     i);
1804
            if (!strcmp(ost->enc->name, "libx264")) {
1805
                av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1806
            } else {
1807
                if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1808
                    char  *logbuffer = read_file(logfilename);
1809
1810
                    if (!logbuffer) {
1811
                        av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1812
                               logfilename);
1813
                        exit_program(1);
1814
                    }
1815
                    video_enc->stats_in = logbuffer;
1816
                }
1817
                if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1818
                    f = av_fopen_utf8(logfilename, "wb");
1819
                    if (!f) {
1820
                        av_log(NULL, AV_LOG_FATAL,
1821
                               "Cannot write log file '%s' for pass-1 encoding: %s\n",
1822
                               logfilename, strerror(errno));
1823
                        exit_program(1);
1824
                    }
1825
                    ost->logfile = f;
1826
                }
1827
            }
1828
        }
1829
1830

4591
        MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1831
4590
        if (ost->forced_keyframes)
1832
1
            ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1833
1834

4590
        MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1835
1836
4590
        ost->top_field_first = -1;
1837

4593
        MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1838
1839
1840
4590
        ost->avfilter = get_ost_filters(o, oc, ost);
1841
4590
        if (!ost->avfilter)
1842
            exit_program(1);
1843
    } else {
1844

145
        MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1845
    }
1846
1847
4735
    if (ost->stream_copy)
1848
145
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1849
1850
4735
    return ost;
1851
}
1852
1853
1189
static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1854
{
1855
    int n;
1856
    AVStream *st;
1857
    OutputStream *ost;
1858
    AVCodecContext *audio_enc;
1859
1860
1189
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1861
1189
    st  = ost->st;
1862
1863
1189
    audio_enc = ost->enc_ctx;
1864
1189
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1865
1866

1190
    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1867

1587
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1868
1189
    if (o->nb_filters > 1)
1869
        av_log(NULL, AV_LOG_ERROR, "Only '-af %s' read, ignoring remaining -af options: Use ',' to separate filters\n", ost->filters);
1870
1871
1189
    if (!ost->stream_copy) {
1872
1092
        char *sample_fmt = NULL;
1873
1874

1104
        MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1875
1876

1092
        MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1877
1092
        if (sample_fmt &&
1878
            (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1879
            av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1880
            exit_program(1);
1881
        }
1882
1883

1117
        MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1884
1885

1092
        MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1886
1092
        ost->apad = av_strdup(ost->apad);
1887
1888
1092
        ost->avfilter = get_ost_filters(o, oc, ost);
1889
1092
        if (!ost->avfilter)
1890
            exit_program(1);
1891
1892
        /* check for channel mapping for this audio stream */
1893
1102
        for (n = 0; n < o->nb_audio_channel_maps; n++) {
1894
10
            AudioChannelMap *map = &o->audio_channel_maps[n];
1895

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

10
                (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1897
                InputStream *ist;
1898
1899
10
                if (map->channel_idx == -1) {
1900
1
                    ist = NULL;
1901
9
                } else if (ost->source_index < 0) {
1902
                    av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1903
                           ost->file_index, ost->st->index);
1904
                    continue;
1905
                } else {
1906
9
                    ist = input_streams[ost->source_index];
1907
                }
1908
1909

10
                if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1910
10
                    if (av_reallocp_array(&ost->audio_channels_map,
1911
10
                                          ost->audio_channels_mapped + 1,
1912
                                          sizeof(*ost->audio_channels_map)
1913
                                          ) < 0 )
1914
                        exit_program(1);
1915
1916
10
                    ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1917
                }
1918
            }
1919
        }
1920
    }
1921
1922
1189
    if (ost->stream_copy)
1923
97
        check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1924
1925
1189
    return ost;
1926
}
1927
1928
10
static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1929
{
1930
    OutputStream *ost;
1931
1932
10
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1933
10
    if (!ost->stream_copy) {
1934
        av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1935
        exit_program(1);
1936
    }
1937
1938
10
    return ost;
1939
}
1940
1941
static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1942
{
1943
    OutputStream *ost;
1944
1945
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1946
    if (!ost->stream_copy) {
1947
        av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1948
        exit_program(1);
1949
    }
1950
1951
    return ost;
1952
}
1953
1954
1
static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1955
{
1956
1
    OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1957
1
    ost->stream_copy = 1;
1958
1
    ost->finished    = 1;
1959
1
    return ost;
1960
}
1961
1962
36
static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1963
{
1964
    AVStream *st;
1965
    OutputStream *ost;
1966
    AVCodecContext *subtitle_enc;
1967
1968
36
    ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1969
36
    st  = ost->st;
1970
36
    subtitle_enc = ost->enc_ctx;
1971
1972
36
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1973
1974

36
    MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1975
1976
36
    if (!ost->stream_copy) {
1977
30
        char *frame_size = NULL;
1978
1979

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

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

10
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2036
            break;
2037
2038
10
        out_ch = av_mallocz(sizeof(AVChapter));
2039
10
        if (!out_ch)
2040
            return AVERROR(ENOMEM);
2041
2042
10
        out_ch->id        = in_ch->id;
2043
10
        out_ch->time_base = in_ch->time_base;
2044
10
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
2045
10
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
2046
2047
10
        if (copy_metadata)
2048
10
            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2049
2050
10
        os->chapters[os->nb_chapters++] = out_ch;
2051
    }
2052
10
    return 0;
2053
}
2054
2055
75
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2056
                               AVFormatContext *oc)
2057
{
2058
    OutputStream *ost;
2059
2060
75
    switch (ofilter->type) {
2061
60
    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2062
15
    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2063
    default:
2064
        av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2065
               "currently.\n");
2066
        exit_program(1);
2067
    }
2068
2069
75
    ost->source_index = -1;
2070
75
    ost->filter       = ofilter;
2071
2072
75
    ofilter->ost      = ost;
2073
75
    ofilter->format   = -1;
2074
2075
75
    if (ost->stream_copy) {
2076
        av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2077
               "which is fed from a complex filtergraph. Filtering and streamcopy "
2078
               "cannot be used together.\n", ost->file_index, ost->index);
2079
        exit_program(1);
2080
    }
2081
2082

75
    if (ost->avfilter && (ost->filters || ost->filters_script)) {
2083
        const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2084
        av_log(NULL, AV_LOG_ERROR,
2085
               "%s '%s' was specified through the %s option "
2086
               "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2087
               "%s and -filter_complex cannot be used together for the same stream.\n",
2088
               ost->filters ? "Filtergraph" : "Filtergraph script",
2089
               ost->filters ? ost->filters : ost->filters_script,
2090
               opt, ost->file_index, ost->index, opt);
2091
        exit_program(1);
2092
    }
2093
2094
75
    avfilter_inout_free(&ofilter->out_tmp);
2095
75
}
2096
2097
5829
static int init_complex_filters(void)
2098
{
2099
5829
    int i, ret = 0;
2100
2101
5901
    for (i = 0; i < nb_filtergraphs; i++) {
2102
72
        ret = init_complex_filtergraph(filtergraphs[i]);
2103
72
        if (ret < 0)
2104
            return ret;
2105
    }
2106
5829
    return 0;
2107
}
2108
2109
5830
static int open_output_file(OptionsContext *o, const char *filename)
2110
{
2111
    AVFormatContext *oc;
2112
    int i, j, err;
2113
    OutputFile *of;
2114
    OutputStream *ost;
2115
    InputStream  *ist;
2116
5830
    AVDictionary *unused_opts = NULL;
2117
5830
    AVDictionaryEntry *e = NULL;
2118
5830
    int format_flags = 0;
2119
2120

5830
    if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2121
        o->stop_time = INT64_MAX;
2122
        av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2123
    }
2124
2125

5830
    if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2126
        int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2127
        if (o->stop_time <= start_time) {
2128
            av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2129
            exit_program(1);
2130
        } else {
2131
            o->recording_time = o->stop_time - start_time;
2132
        }
2133
    }
2134
2135
5830
    GROW_ARRAY(output_files, nb_output_files);
2136
5830
    of = av_mallocz(sizeof(*of));
2137
5830
    if (!of)
2138
        exit_program(1);
2139
5830
    output_files[nb_output_files - 1] = of;
2140
2141
5830
    of->ost_index      = nb_output_streams;
2142
5830
    of->recording_time = o->recording_time;
2143
5830
    of->start_time     = o->start_time;
2144
5830
    of->limit_filesize = o->limit_filesize;
2145
5830
    of->shortest       = o->shortest;
2146
5830
    av_dict_copy(&of->opts, o->g->format_opts, 0);
2147
2148
5830
    if (!strcmp(filename, "-"))
2149
2180
        filename = "pipe:";
2150
2151
5830
    err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2152
5830
    if (!oc) {
2153
        print_error(filename, err);
2154
        exit_program(1);
2155
    }
2156
2157
5830
    of->ctx = oc;
2158
5830
    if (o->recording_time != INT64_MAX)
2159
125
        oc->duration = o->recording_time;
2160
2161
5830
    oc->interrupt_callback = int_cb;
2162
2163
5830
    e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2164
5830
    if (e) {
2165
3333
        const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2166
3333
        av_opt_eval_flags(oc, o, e->value, &format_flags);
2167
    }
2168
5830
    if (o->bitexact) {
2169
1608
        format_flags |= AVFMT_FLAG_BITEXACT;
2170
1608
        oc->flags    |= AVFMT_FLAG_BITEXACT;
2171
    }
2172
2173
    /* create streams for all unlabeled output pads */
2174
5903
    for (i = 0; i < nb_filtergraphs; i++) {
2175
73
        FilterGraph *fg = filtergraphs[i];
2176
149
        for (j = 0; j < fg->nb_outputs; j++) {
2177
76
            OutputFilter *ofilter = fg->outputs[j];
2178
2179

76
            if (!ofilter->out_tmp || ofilter->out_tmp->name)
2180
4
                continue;
2181
2182

72
            switch (ofilter->type) {
2183
58
            case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
2184
14
            case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
2185
            case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2186
            }
2187
72
            init_output_filter(ofilter, o, oc);
2188
        }
2189
    }
2190
2191
5830
    if (!o->nb_stream_maps) {
2192
5789
        char *subtitle_codec_name = NULL;
2193
        /* pick the "best" stream of each type */
2194
2195
        /* video: highest resolution */
2196

5789
        if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2197
4893
            int area = 0, idx = -1;
2198
4893
            int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2199
10065
            for (i = 0; i < nb_input_streams; i++) {
2200
                int new_area;
2201
5172
                ist = input_streams[i];
2202
5172
                new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2203
5172
                           + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2204
5172
                if (ist->user_set_discard == AVDISCARD_ALL)
2205
                    continue;
2206

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

5172
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2209
                    new_area > area) {
2210

4654
                    if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2211
                        continue;
2212
4654
                    area = new_area;
2213
4654
                    idx = i;
2214
                }
2215
            }
2216
4893
            if (idx >= 0)
2217
4654
                new_video_stream(o, oc, idx);
2218
        }
2219
2220
        /* audio: most channels */
2221

5789
        if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2222
4913
            int best_score = 0, idx = -1;
2223
10002
            for (i = 0; i < nb_input_streams; i++) {
2224
                int score;
2225
5089
                ist = input_streams[i];
2226
5089
                score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2227
5089
                        + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2228
5089
                if (ist->user_set_discard == AVDISCARD_ALL)
2229
                    continue;
2230

5089
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2231
                    score > best_score) {
2232
1145
                    best_score = score;
2233
1145
                    idx = i;
2234
                }
2235
            }
2236
4913
            if (idx >= 0)
2237
1145
                new_audio_stream(o, oc, idx);
2238
        }
2239
2240
        /* subtitles: pick first */
2241

9143
        MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2242

5789
        if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2243
53
            for (i = 0; i < nb_input_streams; i++)
2244
46
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2245
                    AVCodecDescriptor const *input_descriptor =
2246
34
                        avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2247
34
                    AVCodecDescriptor const *output_descriptor = NULL;
2248
                    AVCodec const *output_codec =
2249
34
                        avcodec_find_encoder(oc->oformat->subtitle_codec);
2250
34
                    int input_props = 0, output_props = 0;
2251
34
                    if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2252
                        continue;
2253
34
                    if (output_codec)
2254
33
                        output_descriptor = avcodec_descriptor_get(output_codec->id);
2255
34
                    if (input_descriptor)
2256
34
                        input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2257
34
                    if (output_descriptor)
2258
33
                        output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2259
34
                    if (subtitle_codec_name ||
2260

28
                        input_props & output_props ||
2261
                        // Map dvb teletext which has neither property to any output subtitle encoder
2262
                        input_descriptor && output_descriptor &&
2263
                        (!input_descriptor->props ||
2264
                         !output_descriptor->props)) {
2265
34
                        new_subtitle_stream(o, oc, i);
2266
34
                        break;
2267
                    }
2268
                }
2269
        }
2270
        /* Data only if codec id match */
2271
5789
        if (!o->data_disable ) {
2272
5789
            enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2273

5789
            for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2274
                if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2275
                    continue;
2276
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2277
                    && input_streams[i]->st->codecpar->codec_id == codec_id )
2278
                    new_data_stream(o, oc, i);
2279
            }
2280
        }
2281
    } else {
2282
106
        for (i = 0; i < o->nb_stream_maps; i++) {
2283
65
            StreamMap *map = &o->stream_maps[i];
2284
2285
65
            if (map->disabled)
2286
                continue;
2287
2288
65
            if (map->linklabel) {
2289
                FilterGraph *fg;
2290
3
                OutputFilter *ofilter = NULL;
2291
                int j, k;
2292
2293
3
                for (j = 0; j < nb_filtergraphs; j++) {
2294
3
                    fg = filtergraphs[j];
2295
3
                    for (k = 0; k < fg->nb_outputs; k++) {
2296
3
                        AVFilterInOut *out = fg->outputs[k]->out_tmp;
2297

3
                        if (out && !strcmp(out->name, map->linklabel)) {
2298
3
                            ofilter = fg->outputs[k];
2299
3
                            goto loop_end;
2300
                        }
2301
                    }
2302
                }
2303
loop_end:
2304
3
                if (!ofilter) {
2305
                    av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2306
                           "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2307
                    exit_program(1);
2308
                }
2309
3
                init_output_filter(ofilter, o, oc);
2310
            } else {
2311
62
                int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2312
2313
62
                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2314
62
                if (ist->user_set_discard == AVDISCARD_ALL) {
2315
                    av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2316
                           map->file_index, map->stream_index);
2317
                    exit_program(1);
2318
                }
2319

62
                if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2320
                    continue;
2321

62
                if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2322
                    continue;
2323

62
                if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2324
                    continue;
2325

62
                if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2326
                    continue;
2327
2328
62
                ost = NULL;
2329

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

1
        av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2391
1
        avio_closep(&pb);
2392
    }
2393
2394
#if FF_API_LAVF_AVCTX
2395
11801
    for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2396
        AVDictionaryEntry *e;
2397
5971
        ost = output_streams[i];
2398
2399

5971
        if ((ost->stream_copy || ost->attachment_filename)
2400
259
            && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2401

59
            && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2402
59
            if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2403
                exit_program(1);
2404
    }
2405
#endif
2406
2407

5830
    if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2408
        av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2409
        av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2410
        exit_program(1);
2411
    }
2412
2413
    /* check if all codec options have been used */
2414
5830
    unused_opts = strip_specifiers(o->g->codec_opts);
2415
11801
    for (i = of->ost_index; i < nb_output_streams; i++) {
2416
5971
        e = NULL;
2417
19682
        while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2418
                                AV_DICT_IGNORE_SUFFIX)))
2419
13711
            av_dict_set(&unused_opts, e->key, NULL, 0);
2420
    }
2421
2422
5830
    e = NULL;
2423
6078
    while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2424
248
        const AVClass *class = avcodec_get_class();
2425
248
        const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2426
                                             AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2427
248
        const AVClass *fclass = avformat_get_class();
2428
248
        const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2429
                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2430

248
        if (!option || foption)
2431
9
            continue;
2432
2433
2434
247
        if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2435
            av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2436
                   "output file #%d (%s) is not an encoding option.\n", e->key,
2437
                   option->help ? option->help : "", nb_output_files - 1,
2438
                   filename);
2439
            exit_program(1);
2440
        }
2441
2442
        // gop_timecode is injected by generic code but not always used
2443
247
        if (!strcmp(e->key, "gop_timecode"))
2444
8
            continue;
2445
2446
239
        av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2447
               "output file #%d (%s) has not been used for any stream. The most "
2448
               "likely reason is either wrong type (e.g. a video option with "
2449
               "no video streams) or that it is a private option of some encoder "
2450
               "which was not actually used for any stream.\n", e->key,
2451
239
               option->help ? option->help : "", nb_output_files - 1, filename);
2452
    }
2453
5830
    av_dict_free(&unused_opts);
2454
2455
    /* set the decoding_needed flags and create simple filtergraphs */
2456
11801
    for (i = of->ost_index; i < nb_output_streams; i++) {
2457
5971
        OutputStream *ost = output_streams[i];
2458
2459

5971
        if (ost->encoding_needed && ost->source_index >= 0) {
2460
5637
            InputStream *ist = input_streams[ost->source_index];
2461
5637
            ist->decoding_needed |= DECODING_FOR_OST;
2462
2463
5637
            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2464
1107
                ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2465
5607
                err = init_simple_filtergraph(ist, ost);
2466
5607
                if (err < 0) {
2467
                    av_log(NULL, AV_LOG_ERROR,
2468
                           "Error initializing a simple filtergraph between streams "
2469
                           "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2470
                           nb_output_files - 1, ost->st->index);
2471
                    exit_program(1);
2472
                }
2473
            }
2474
        }
2475
2476
        /* set the filter output constraints */
2477
5971
        if (ost->filter) {
2478
5682
            OutputFilter *f = ost->filter;
2479
            int count;
2480
5682
            switch (ost->enc_ctx->codec_type) {
2481
4590
            case AVMEDIA_TYPE_VIDEO:
2482
4590
                f->frame_rate = ost->frame_rate;
2483
4590
                f->width      = ost->enc_ctx->width;
2484
4590
                f->height     = ost->enc_ctx->height;
2485
4590
                if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2486
3295
                    f->format = ost->enc_ctx->pix_fmt;
2487
1295
                } else if (ost->enc->pix_fmts) {
2488
290
                    count = 0;
2489
1474
                    while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2490
1184
                        count++;
2491
290
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2492
290
                    if (!f->formats)
2493
                        exit_program(1);
2494
290
                    memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2495
                }
2496
4590
                break;
2497
1092
            case AVMEDIA_TYPE_AUDIO:
2498
1092
                if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2499
                    f->format = ost->enc_ctx->sample_fmt;
2500
1092
                } else if (ost->enc->sample_fmts) {
2501
1092
                    count = 0;
2502
2218
                    while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2503
1126
                        count++;
2504
1092
                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2505
1092
                    if (!f->formats)
2506
                        exit_program(1);
2507
1092
                    memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2508
                }
2509
1092
                if (ost->enc_ctx->sample_rate) {
2510
25
                    f->sample_rate = ost->enc_ctx->sample_rate;
2511
1067
                } else if (ost->enc->supported_samplerates) {
2512
29
                    count = 0;
2513
281
                    while (ost->enc->supported_samplerates[count])
2514
252
                        count++;
2515
29
                    f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2516
29
                    if (!f->sample_rates)
2517
                        exit_program(1);
2518
29
                    memcpy(f->sample_rates, ost->enc->supported_samplerates,
2519
29
                           (count + 1) * sizeof(*f->sample_rates));
2520
                }
2521
1092
                if (ost->enc_ctx->channels) {
2522
12
                    f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2523
1080
                } else if (ost->enc->channel_layouts) {
2524
42
                    count = 0;
2525
280
                    while (ost->enc->channel_layouts[count])
2526
238
                        count++;
2527
42
                    f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2528
42
                    if (!f->channel_layouts)
2529
                        exit_program(1);
2530
42
                    memcpy(f->channel_layouts, ost->enc->channel_layouts,
2531
42
                           (count + 1) * sizeof(*f->channel_layouts));
2532
                }
2533
1092
                break;
2534
            }
2535
5971
        }
2536
    }
2537
2538
    /* check filename in case of an image number is expected */
2539
5830
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2540
        if (!av_filename_number_test(oc->url)) {
2541
            print_error(oc->url, AVERROR(EINVAL));
2542
            exit_program(1);
2543
        }
2544
    }
2545
2546

5830
    if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2547
        av_log(NULL, AV_LOG_ERROR,
2548
               "No input streams but output needs an input stream\n");
2549
        exit_program(1);
2550
    }
2551
2552
5830
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2553
        /* test if it already exists to avoid losing precious files */
2554
5777
        assert_file_overwrite(filename);
2555
2556
        /* open the file */
2557
5777
        if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2558
5777
                              &oc->interrupt_callback,
2559
                              &of->opts)) < 0) {
2560
            print_error(filename, err);
2561
            exit_program(1);
2562
        }
2563

53
    } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2564
        assert_file_overwrite(filename);
2565
2566
5830
    if (o->mux_preload) {
2567
        av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2568
    }
2569
5830
    oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2570
2571
    /* copy metadata */
2572
5835
    for (i = 0; i < o->nb_metadata_map; i++) {
2573
        char *p;
2574
5
        int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2575
2576
5
        if (in_file_index >= nb_input_files) {
2577
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2578
            exit_program(1);
2579
        }
2580

8
        copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2581
                      in_file_index >= 0 ?
2582
3
                      input_files[in_file_index]->ctx : NULL, o);
2583
    }
2584
2585
    /* copy chapters */
2586
5830
    if (o->chapters_input_file >= nb_input_files) {
2587
5830
        if (o->chapters_input_file == INT_MAX) {
2588
            /* copy chapters from the first input file that has them*/
2589
5830
            o->chapters_input_file = -1;
2590
11682
            for (i = 0; i < nb_input_files; i++)
2591
5862
                if (input_files[i]->ctx->nb_chapters) {
2592
10
                    o->chapters_input_file = i;
2593
10
                    break;
2594
                }
2595
        } else {
2596
            av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2597
                   o->chapters_input_file);
2598
            exit_program(1);
2599
        }
2600
    }
2601
5830
    if (o->chapters_input_file >= 0)
2602
10
        copy_chapters(input_files[o->chapters_input_file], of,
2603
10
                      !o->metadata_chapters_manual);
2604
2605
    /* copy global metadata by default */
2606

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

131
            switch (type) {
2727
131
            case 'g':
2728
131
                m = &oc->metadata;
2729
131
                break;
2730
            case 'c':
2731
                if (index < 0 || index >= oc->nb_chapters) {
2732
                    av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2733
                    exit_program(1);
2734
                }
2735
                m = &oc->chapters[index]->metadata;
2736
                break;
2737
            case 'p':
2738
                if (index < 0 || index >= oc->nb_programs) {
2739
                    av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2740
                    exit_program(1);
2741
                }
2742
                m = &oc->programs[index]->metadata;
2743
                break;
2744
            default:
2745
                av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2746
                exit_program(1);
2747
            }
2748
131
            av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2749
        }
2750
    }
2751
2752
5830
    return 0;
2753
}
2754
2755
static int opt_target(void *optctx, const char *opt, const char *arg)
2756
{
2757
    OptionsContext *o = optctx;
2758
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2759
    static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2760
2761
    if (!strncmp(arg, "pal-", 4)) {
2762
        norm = PAL;
2763
        arg += 4;
2764
    } else if (!strncmp(arg, "ntsc-", 5)) {
2765
        norm = NTSC;
2766
        arg += 5;
2767
    } else if (!strncmp(arg, "film-", 5)) {
2768
        norm = FILM;
2769
        arg += 5;
2770
    } else {
2771
        /* Try to determine PAL/NTSC by peeking in the input files */
2772
        if (nb_input_files) {
2773
            int i, j;
2774
            for (j = 0; j < nb_input_files; j++) {
2775
                for (i = 0; i < input_files[j]->nb_streams; i++) {
2776
                    AVStream *st = input_files[j]->ctx->streams[i];
2777
                    int64_t fr;
2778
                    if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2779
                        continue;
2780
                    fr = st->time_base.den * 1000LL / st->time_base.num;
2781
                    if (fr == 25000) {
2782
                        norm = PAL;
2783
                        break;
2784
                    } else if ((fr == 29970) || (fr == 23976)) {
2785
                        norm = NTSC;
2786
                        break;
2787
                    }
2788
                }
2789
                if (norm != UNKNOWN)
2790
                    break;
2791
            }
2792
        }
2793
        if (norm != UNKNOWN)
2794
            av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2795
    }
2796
2797
    if (norm == UNKNOWN) {
2798
        av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2799
        av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2800
        av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2801
        exit_program(1);
2802
    }
2803
2804
    if (!strcmp(arg, "vcd")) {
2805
        opt_video_codec(o, "c:v", "mpeg1video");
2806
        opt_audio_codec(o, "c:a", "mp2");
2807
        parse_option(o, "f", "vcd", options);
2808
2809
        parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2810
        parse_option(o, "r", frame_rates[norm], options);
2811
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2812
2813
        opt_default(NULL, "b:v", "1150000");
2814
        opt_default(NULL, "maxrate:v", "1150000");
2815
        opt_default(NULL, "minrate:v", "1150000");
2816
        opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2817
2818
        opt_default(NULL, "b:a", "224000");
2819
        parse_option(o, "ar", "44100", options);
2820
        parse_option(o, "ac", "2", options);
2821
2822
        opt_default(NULL, "packetsize", "2324");
2823
        opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2824
2825
        /* We have to offset the PTS, so that it is consistent with the SCR.
2826
           SCR starts at 36000, but the first two packs contain only padding
2827
           and the first pack from the other stream, respectively, may also have
2828
           been written before.
2829
           So the real data starts at SCR 36000+3*1200. */
2830
        o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2831
    } else if (!strcmp(arg, "svcd")) {
2832
2833
        opt_video_codec(o, "c:v", "mpeg2video");
2834
        opt_audio_codec(o, "c:a", "mp2");
2835
        parse_option(o, "f", "svcd", options);
2836
2837
        parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2838
        parse_option(o, "r", frame_rates[norm], options);
2839
        parse_option(o, "pix_fmt", "yuv420p", options);
2840
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2841
2842
        opt_default(NULL, "b:v", "2040000");
2843
        opt_default(NULL, "maxrate:v", "2516000");
2844
        opt_default(NULL, "minrate:v", "0"); // 1145000;
2845
        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2846
        opt_default(NULL, "scan_offset", "1");
2847
2848
        opt_default(NULL, "b:a", "224000");
2849
        parse_option(o, "ar", "44100", options);
2850
2851
        opt_default(NULL, "packetsize", "2324");
2852
2853
    } else if (!strcmp(arg, "dvd")) {
2854
2855
        opt_video_codec(o, "c:v", "mpeg2video");
2856
        opt_audio_codec(o, "c:a", "ac3");
2857
        parse_option(o, "f", "dvd", options);
2858
2859
        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2860
        parse_option(o, "r", frame_rates[norm], options);
2861
        parse_option(o, "pix_fmt", "yuv420p", options);
2862
        opt_default(NULL, "g", norm == PAL ? "15" : "18");
2863
2864
        opt_default(NULL, "b:v", "6000000");
2865
        opt_default(NULL, "maxrate:v", "9000000");
2866
        opt_default(NULL, "minrate:v", "0"); // 1500000;
2867
        opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2868
2869
        opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2870
        opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2871
2872
        opt_default(NULL, "b:a", "448000");
2873
        parse_option(o, "ar", "48000", options);
2874
2875
    } else if (!strncmp(arg, "dv", 2)) {
2876
2877
        parse_option(o, "f", "dv", options);
2878
2879
        parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2880
        parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2881
                          norm == PAL ? "yuv420p" : "yuv411p", options);
2882
        parse_option(o, "r", frame_rates[norm], options);
2883
2884
        parse_option(o, "ar", "48000", options);
2885
        parse_option(o, "ac", "2", options);
2886
2887
    } else {
2888
        av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2889
        return AVERROR(EINVAL);
2890
    }
2891
2892
    av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2893
    av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2894
2895
    return 0;
2896
}
2897
2898
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2899
{
2900
    av_free (vstats_filename);
2901
    vstats_filename = av_strdup (arg);
2902
    return 0;
2903
}
2904
2905
static int opt_vstats(void *optctx, const char *opt, const char *arg)
2906
{
2907
    char filename[40];
2908
    time_t today2 = time(NULL);
2909
    struct tm *today = localtime(&today2);
2910
2911
    if (!today) { // maybe tomorrow
2912
        av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2913
        exit_program(1);
2914
    }
2915
2916
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2917
             today->tm_sec);
2918
    return opt_vstats_file(NULL, opt, filename);
2919
}
2920
2921
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2922
{
2923
    OptionsContext *o = optctx;
2924
    return parse_option(o, "frames:v", arg, options);
2925
}
2926
2927
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2928
{
2929
    OptionsContext *o = optctx;
2930
    return parse_option(o, "frames:a", arg, options);
2931
}
2932
2933
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2934
{
2935
    OptionsContext *o = optctx;
2936
    return parse_option(o, "frames:d", arg, options);
2937
}
2938
2939
2
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2940
{
2941
    int ret;
2942
2
    AVDictionary *cbak = codec_opts;
2943
2
    AVDictionary *fbak = format_opts;
2944
2
    codec_opts = NULL;
2945
2
    format_opts = NULL;
2946
2947
2
    ret = opt_default(NULL, opt, arg);
2948
2949
2
    av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2950
2
    av_dict_copy(&o->g->format_opts, format_opts, 0);
2951
2
    av_dict_free(&codec_opts);
2952
2
    av_dict_free(&format_opts);
2953
2
    codec_opts = cbak;
2954
2
    format_opts = fbak;
2955
2956
2
    return ret;
2957
}
2958
2959
static int opt_preset(void *optctx, const char *opt, const char *arg)
2960
{
2961
    OptionsContext *o = optctx;
2962
    FILE *f=NULL;
2963
    char filename[1000], line[1000], tmp_line[1000];
2964
    const char *codec_name = NULL;
2965
2966
    tmp_line[0] = *opt;
2967
    tmp_line[1] = 0;
2968
    MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2969
2970
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2971
        if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2972
            av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2973
        }else
2974
            av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2975
        exit_program(1);
2976
    }
2977
2978
    while (fgets(line, sizeof(line), f)) {
2979
        char *key = tmp_line, *value, *endptr;
2980
2981
        if (strcspn(line, "#\n\r") == 0)
2982
            continue;
2983
        av_strlcpy(tmp_line, line, sizeof(tmp_line));
2984
        if (!av_strtok(key,   "=",    &value) ||
2985
            !av_strtok(value, "\r\n", &endptr)) {
2986
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2987
            exit_program(1);
2988
        }
2989
        av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2990
2991
        if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2992
        else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2993
        else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2994
        else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2995
        else if (opt_default_new(o, key, value) < 0) {
2996
            av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2997
                   filename, line, key, value);
2998
            exit_program(1);
2999
        }
3000
    }
3001
3002
    fclose(f);
3003
3004
    return 0;
3005
}
3006
3007
3
static int opt_old2new(void *optctx, const char *opt, const char *arg)
3008
{
3009
3
    OptionsContext *o = optctx;
3010
    int ret;
3011
3
    char *s = av_asprintf("%s:%c", opt + 1, *opt);
3012
3
    if (!s)
3013
        return AVERROR(ENOMEM);
3014
3
    ret = parse_option(o, s, arg, options);
3015
3
    av_free(s);
3016
3
    return ret;
3017
}
3018
3019
153
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3020
{
3021
153
    OptionsContext *o = optctx;
3022
3023
153
    if(!strcmp(opt, "ab")){
3024
1
        av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3025
1
        return 0;
3026
152
    } else if(!strcmp(opt, "b")){
3027
39
        av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3028
39
        av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3029
39
        return 0;
3030
    }
3031
113
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
3032
113
    return 0;
3033
}
3034
3035
254
static int opt_qscale(void *optctx, const char *opt, const char *arg)
3036
{
3037
254
    OptionsContext *o = optctx;
3038
    char *s;
3039
    int ret;
3040
254
    if(!strcmp(opt, "qscale")){
3041
215
        av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3042
215
        return parse_option(o, "q:v", arg, options);
3043
    }
3044
39
    s = av_asprintf("q%s", opt + 6);
3045
39
    if (!s)
3046
        return AVERROR(ENOMEM);
3047
39
    ret = parse_option(o, s, arg, options);
3048
39
    av_free(s);
3049
39
    return ret;
3050
}
3051
3052
45
static int opt_profile(void *optctx, const char *opt, const char *arg)
3053
{
3054
45
    OptionsContext *o = optctx;
3055
45
    if(!strcmp(opt, "profile")){
3056
4
        av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3057
4
        av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3058
4
        return 0;
3059
    }
3060
41
    av_dict_set(&o->g->codec_opts, opt, arg, 0);
3061
41
    return 0;
3062
}
3063
3064
2169
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3065
{
3066
2169
    OptionsContext *o = optctx;
3067
2169
    return parse_option(o, "filter:v", arg, options);
3068
}
3069
3070
380
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3071
{
3072
380
    OptionsContext *o = optctx;
3073
380
    return parse_option(o, "filter:a", arg, options);
3074
}
3075
3076
801
static int opt_vsync(void *optctx, const char *opt, const char *arg)
3077
{
3078
801
    if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3079
797
    else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3080
796
    else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3081
795
    else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
3082
3083
801
    if (video_sync_method == VSYNC_AUTO)
3084
473
        video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3085
801
    return 0;
3086
}
3087
3088
15
static int opt_timecode(void *optctx, const char *opt, const char *arg)
3089
{
3090
15
    OptionsContext *o = optctx;
3091
    int ret;
3092
15
    char *tcr = av_asprintf("timecode=%s", arg);
3093
15
    if (!tcr)
3094
        return AVERROR(ENOMEM);
3095
15
    ret = parse_option(o, "metadata:g", tcr, options);
3096
15
    if (ret >= 0)
3097
15
        ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3098
15
    av_free(tcr);
3099
15
    return ret;
3100
}
3101
3102
2
static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3103
{
3104
2
    OptionsContext *o = optctx;
3105
    char layout_str[32];
3106
    char *stream_str;
3107
    char *ac_str;
3108
    int ret, channels, ac_str_size;
3109
    uint64_t layout;
3110
3111
2
    layout = av_get_channel_layout(arg);
3112
2
    if (!layout) {
3113
        av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3114
        return AVERROR(EINVAL);
3115
    }
3116
2
    snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3117
2
    ret = opt_default_new(o, opt, layout_str);
3118
2
    if (ret < 0)
3119
        return ret;
3120
3121
    /* set 'ac' option based on channel layout */
3122
2
    channels = av_get_channel_layout_nb_channels(layout);
3123
2
    snprintf(layout_str, sizeof(layout_str), "%d", channels);
3124
2
    stream_str = strchr(opt, ':');
3125
2
    ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3126
2
    ac_str = av_mallocz(ac_str_size);
3127
2
    if (!ac_str)
3128
        return AVERROR(ENOMEM);
3129
2
    av_strlcpy(ac_str, "ac", 3);
3130
2
    if (stream_str)
3131
        av_strlcat(ac_str, stream_str, ac_str_size);
3132
2
    ret = parse_option(o, ac_str, layout_str, options);
3133
2
    av_free(ac_str);
3134
3135
2
    return ret;
3136
}
3137
3138
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3139
{
3140
    OptionsContext *o = optctx;
3141
    return parse_option(o, "q:a", arg, options);
3142
}
3143
3144
50
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3145
{
3146
50
    GROW_ARRAY(filtergraphs, nb_filtergraphs);
3147
50
    if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3148
        return AVERROR(ENOMEM);
3149
50
    filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3150
50
    filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3151
50
    if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3152
        return AVERROR(ENOMEM);
3153
3154
50
    input_stream_potentially_available = 1;
3155
3156
50
    return 0;
3157
}
3158
3159
22
static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3160
{
3161
22
    uint8_t *graph_desc = read_file(arg);
3162
22
    if (!graph_desc)
3163
        return AVERROR(EINVAL);
3164
3165
22
    GROW_ARRAY(filtergraphs, nb_filtergraphs);
3166
22
    if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3167
        return AVERROR(ENOMEM);
3168
22
    filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3169
22
    filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3170
3171
22
    input_stream_potentially_available = 1;
3172
3173
22
    return 0;
3174
}
3175
3176
void show_help_default(const char *opt, const char *arg)
3177
{
3178
    /* per-file options have at least one of those set */
3179
    const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3180
    int show_advanced = 0, show_avoptions = 0;
3181
3182
    if (opt && *opt) {
3183
        if (!strcmp(opt, "long"))
3184
            show_advanced = 1;
3185
        else if (!strcmp(opt, "full"))
3186
            show_advanced = show_avoptions = 1;
3187
        else
3188
            av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3189
    }
3190
3191
    show_usage();
3192
3193
    printf("Getting help:\n"
3194
           "    -h      -- print basic options\n"
3195
           "    -h long -- print more options\n"
3196
           "    -h full -- print all options (including all format and codec specific options, very long)\n"
3197
           "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf\n"
3198
           "    See man %s for detailed description of the options.\n"
3199
           "\n", program_name);
3200
3201
    show_help_options(options, "Print help / information / capabilities:",
3202
                      OPT_EXIT, 0, 0);
3203
3204
    show_help_options(options, "Global options (affect whole program "
3205
                      "instead of just one file:",
3206
                      0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3207
    if (show_advanced)
3208
        show_help_options(options, "Advanced global options:", OPT_EXPERT,
3209
                          per_file | OPT_EXIT, 0);
3210
3211
    show_help_options(options, "Per-file main options:", 0,
3212
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3213
                      OPT_EXIT, per_file);
3214
    if (show_advanced)
3215
        show_help_options(options, "Advanced per-file options:",
3216
                          OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3217
3218
    show_help_options(options, "Video options:",
3219
                      OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3220
    if (show_advanced)
3221
        show_help_options(options, "Advanced Video options:",
3222
                          OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3223
3224
    show_help_options(options, "Audio options:",
3225
                      OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3226
    if (show_advanced)
3227
        show_help_options(options, "Advanced Audio options:",
3228
                          OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3229
    show_help_options(options, "Subtitle options:",
3230
                      OPT_SUBTITLE, 0, 0);
3231
    printf("\n");
3232
3233
    if (show_avoptions) {
3234
        int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3235
        show_help_children(avcodec_get_class(), flags);
3236
        show_help_children(avformat_get_class(), flags);
3237
#if CONFIG_SWSCALE
3238
        show_help_children(sws_get_class(), flags);
3239
#endif
3240
#if CONFIG_SWRESAMPLE
3241
        show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3242
#endif
3243
        show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3244
        show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3245
    }
3246
}
3247
3248
void show_usage(void)
3249
{
3250
    av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3251
    av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3252
    av_log(NULL, AV_LOG_INFO, "\n");
3253
}
3254
3255
enum OptGroup {
3256
    GROUP_OUTFILE,
3257
    GROUP_INFILE,
3258
};
3259
3260
static const OptionGroupDef groups[] = {
3261
    [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
3262
    [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
3263
};
3264
3265
11659
static int open_files(OptionGroupList *l, const char *inout,
3266
                      int (*open_file)(OptionsContext*, const char*))
3267
{
3268
    int i, ret;
3269
3270
23350
    for (i = 0; i < l->nb_groups; i++) {
3271
11692
        OptionGroup *g = &l->groups[i];
3272
        OptionsContext o;
3273
3274
11692
        init_options(&o);
3275
11692
        o.g = g;
3276
3277
11692
        ret = parse_optgroup(&o, g);
3278
11692
        if (ret < 0) {
3279
            av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3280
                   "%s.\n", inout, g->arg);
3281
            return ret;
3282
        }
3283
3284
11692
        av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3285
11692
        ret = open_file(&o, g->arg);
3286
11691
        uninit_options(&o);
3287
11691
        if (ret < 0) {
3288
            av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3289
                   inout, g->arg);
3290
            return ret;
3291
        }
3292
11691
        av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3293
    }
3294
3295
11658
    return 0;
3296
}
3297
3298
5831
int ffmpeg_parse_options(int argc, char **argv)
3299
{
3300
    OptionParseContext octx;
3301
    uint8_t error[128];
3302
    int ret;
3303
3304
5831
    memset(&octx, 0, sizeof(octx));
3305
3306
    /* split the commandline into an internal representation */
3307
5831
    ret = split_commandline(&octx, argc, argv, options, groups,
3308
                            FF_ARRAY_ELEMS(groups));
3309
5831
    if (ret < 0) {
3310
        av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3311
        goto fail;
3312
    }
3313
3314
    /* apply global options */
3315
5831
    ret = parse_optgroup(NULL, &octx.global_opts);
3316
5830
    if (ret < 0) {
3317
        av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3318
        goto fail;
3319
    }
3320
3321